Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

CompletableFuture — composición de cálculos asíncronos

CompletableFuture<T> representa un resultado futuro y permite enlazar etapas dependientes sin bloquear después de cada paso. Aprende transformaciones, composición, combinación de resultados, recuperación de errores y límites de tiempo en Java SE 21.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

CompletableFuture<T> future = CompletableFuture.supplyAsync(supplier, executor);
CompletableFuture<U> mapped = future.thenApply(mapper);
CompletableFuture<U> composed = future.thenCompose(asyncMapper);
T result = future.join();

CompletableFuture<T> combina un resultado Future<T> con etapas CompletionStage<T>. CompletableFuture.supplyAsync envía un cálculo para su ejecución; CompletableFuture.completedFuture crea un resultado ya completado. CompletableFuture.completeExceptionally completa con un error un future que aún no ha terminado. Ámbito: Java SE 21; entorno de ejecución del repositorio, entorno de producción no acreditado.

CompletableFuture.thenApply transforma un resultado satisfactorio; no garantiza un hilo separado. CompletableFuture.thenApplyAsync envía la función a un executor para que la ejecute. De forma predeterminada se usa ForkJoinPool.commonPool(); si el paralelismo es inferior a dos, se crea un hilo por tarea. Puedes proporcionar un executor explícitamente. CompletableFuture.thenCompose aplana una función que devuelve otra etapa, en lugar de crear un resultado anidado. CompletableFuture.thenCombine combina valores cuando ambas etapas se completan correctamente.

CompletableFuture.exceptionally calcula un valor de sustitución solo si se produce un error. CompletableFuture.allOf espera a todas las etapas, devuelve CompletableFuture<Void> y propaga el error si falla alguna; no recopila los valores. CompletableFuture.anyOf devuelve CompletableFuture<Object> con el resultado o el error de una de las etapas que termine, que no tiene por qué ser un éxito. No cancela las tareas restantes.

CompletableFuture.join y CompletableFuture.get bloquean hasta que se completa la operación. Normalmente, los errores se envuelven en CompletionException, no comprobada, o ExecutionException, comprobada, respectivamente; get también puede lanzar InterruptedException. La cancelación lanza CancellationException. Evita bloquear dentro de tareas dependientes.

CompletableFuture.completeOnTimeout completa el mismo future con un valor alternativo, mientras que CompletableFuture.orTimeout lo completa con TimeoutException si todavía no se ha completado. Ninguno de estos métodos detiene el cálculo subyacente. En cambio, get(timeout, unit) limita únicamente la espera del llamador.

Ejemplos

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        try (var executor = Executors.newFixedThreadPool(2)) {
            var base = CompletableFuture.supplyAsync(() -> 20, executor);
            var result = base
                .thenApply(n -> n + 1)
                .thenCompose(n -> CompletableFuture.completedFuture(n * 2))
                .thenCombine(CompletableFuture.completedFuture(8), Integer::sum);

            var failed = new CompletableFuture<Integer>();
            failed.completeExceptionally(new IllegalStateException("unavailable"));
            var recovered = failed.exceptionally(error -> -1);

            CompletableFuture.allOf(result, recovered).join();
            System.out.println("result=" + result.join());
            System.out.println("recovered=" + recovered.join());
        }
    }
}

Resultado

result=50
recovered=-1

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes