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

CKTIS / Java

CompletableFuture.get(): esperar un resultado

Usa `get()` para obtener el resultado o `get(timeout, unit)` para limitar la espera. A diferencia de `join()`, ambas sobrecargas declaran excepciones comprobadas.

Versión: Java SE 21

Sintaxis

public T get() throws InterruptedException, ExecutionException
public T get(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException, ExecutionException, java.util.concurrent.TimeoutException

En Java SE 21, CompletableFuture.get es un método de instancia de java.util.concurrent.CompletableFuture<T>. Una llamada a get() solo bloquea el hilo que la realiza si necesita esperar a que el futuro se complete. Si ya está completado, no hay espera; si se completó correctamente, el método devuelve el resultado de tipo T.

Ambas sobrecargas lanzan InterruptedException si el hilo que realiza la llamada se interrumpe mientras espera, o ExecutionException si el cálculo falla. Usa getCause() para examinar la causa del fallo. Si se cancela el propio futuro, se lanza CancellationException, que no es comprobada. Las excepciones comprobadas se deben capturar o declarar con throws.

get(long timeout, TimeUnit unit) limita la espera, por ejemplo con future.get(2, TimeUnit.SECONDS). Si el plazo vence antes de que el futuro se complete, la llamada lanza la excepción comprobada TimeoutException; el vencimiento no cancela ni completa el futuro.

join() también puede bloquear y lanza igualmente CancellationException si el futuro se cancela, pero no declara excepciones comprobadas: un fallo del cálculo se notifica como CompletionException, que no es comprobada. Para procesar el resultado sin bloquear en el punto de llamada, añade una etapa como thenApply.

Ejemplos

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<Integer> pending = new CompletableFuture<>();
        try {
            pending.get(0, TimeUnit.MILLISECONDS);
            throw new AssertionError("Expected a timeout");
        } catch (TimeoutException e) {
            System.out.println("Timed out");
        }

        pending.complete(42);
        System.out.println("Result: " + pending.get());

        CompletableFuture<Integer> failed =
                CompletableFuture.failedFuture(new IllegalStateException("No result"));
        try {
            failed.get();
        } catch (ExecutionException e) {
            System.out.println("get cause: " + e.getCause().getMessage());
        }
        try {
            failed.join();
        } catch (CompletionException e) {
            System.out.println("join cause: " + e.getCause().getMessage());
        }
    }
}

Resultado

Timed out
Result: 42
get cause: No result
join cause: No result

El plazo de cero provoca `TimeoutException` porque `pending` aún no se ha completado. Tras `complete(42)`, `get()` devuelve `42` sin esperar. Por último, `get()` y `join()` muestran la misma causa del fallo, envuelta en dos excepciones distintas.

Lecciones relacionadas

  • Java · Lección 51 · Intermedio · Versión: 2

Fuentes