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.TimeoutExceptionEn 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