CKTIS / Java
Future.get: obtener el resultado de una tarea o gestionar su fallo
Obtén el resultado de una tarea asíncrona y distingue su fallo de una interrupción, una cancelación, el vencimiento del plazo de espera o un fallo de la propia llamada a `invokeAll`.
Versión: Java SE 21
Sintaxis
java.util.concurrent.Future<V>
V get() throws InterruptedException, ExecutionException
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutExceptionFuture.get obtiene el resultado de un cálculo asíncrono representado por un java.util.concurrent.Future<V>. Sin argumentos, get() bloquea el hilo que llama si es necesario, sin límite de tiempo. Si la tarea termina correctamente, devuelve un valor de tipo V, que puede ser null si ese fue el resultado de la tarea.
Si la tarea lanza una excepción, get() lanza ExecutionException. Usa getCause() para consultar la excepción original. En cambio, InterruptedException indica que el hilo que llamó fue interrumpido durante la espera, no que la tarea fallara. Si se canceló la tarea, get() lanza la excepción no comprobada CancellationException.
La sobrecarga get(long timeout, TimeUnit unit) tiene los mismos resultados posibles, pero limita el tiempo de espera. Si se agota el plazo mientras se espera, lanza TimeoutException. El vencimiento del plazo no cancela la tarea por sí solo; puedes volver a llamar a get() más adelante.
Cuando ExecutorService.invokeAll(tasks) retorna normalmente, los objetos Future ya están en un estado final y aparecen en el orden de las tareas en la colección. isDone() no implica éxito: es get() sobre el Future de la tarea, y no invokeAll, quien comunica la excepción de la tarea como ExecutionException. La propia llamada a invokeAll puede ser interrumpida durante la espera (InterruptedException) o no poder programar una tarea (RejectedExecutionException). La sobrecarga de invokeAll con plazo cancela las tareas pendientes antes de retornar; get() sobre un Future cancelado lanza CancellationException.
Ejemplos
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutureGetExample {
public static void main(String[] args) throws InterruptedException {
List<Callable<Integer>> tasks = List.of(
() -> 21 * 2,
() -> { throw new IllegalStateException("invalid input"); }
);
try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
List<Future<Integer>> futures = executor.invokeAll(tasks);
System.out.println("invokeAll returned");
for (Future<Integer> future : futures) {
try {
System.out.println("Result: " + future.get());
} catch (ExecutionException e) {
Throwable cause = e.getCause();
System.out.println("Task failed: " + cause.getClass().getSimpleName()
+ ": " + cause.getMessage());
}
}
}
}
}Resultado
invokeAll returned Result: 42 Task failed: IllegalStateException: invalid input
La primera línea muestra que `invokeAll` retornó normalmente. El primer `get()` devuelve `42`; el segundo lanza `ExecutionException`. El programa imprime el tipo y el mensaje de la causa, no los de la excepción que la envuelve. El bloque try-with-resources cierra el ejecutor.
Lecciones relacionadas
- Java · Lección 50 · Intermedio · Versión: 2