CKTIS / Java
Future.get: obter o resultado de uma tarefa ou tratar a sua falha
Obtém o resultado de uma tarefa assíncrona e distingue a sua falha de uma interrupção, de um cancelamento, do fim do tempo de espera ou de uma falha da própria chamada a `invokeAll`.
Versão: Java SE 21
Sintaxe
java.util.concurrent.Future<V>
V get() throws InterruptedException, ExecutionException
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutExceptionFuture.get obtém o resultado de um cálculo assíncrono representado por um java.util.concurrent.Future<V>. Sem argumentos, get() bloqueia a thread que fez a chamada, se necessário, sem limite de tempo. Em caso de sucesso, devolve um valor do tipo V, que pode ser null se esse tiver sido o resultado da tarefa.
Se a tarefa lançar uma exceção, get() lança ExecutionException. Usa getCause() para consultar a exceção original. Já InterruptedException indica que a thread que fez a chamada foi interrompida durante a espera, não que a tarefa tenha falhado. Se a tarefa tiver sido cancelada, get() lança a exceção não verificada CancellationException.
A sobrecarga get(long timeout, TimeUnit unit) tem os mesmos resultados possíveis, mas limita o tempo de espera. Se o limite for atingido durante a espera, lança TimeoutException. O fim do tempo de espera não cancela a tarefa por si só; podes voltar a chamar get() mais tarde.
Quando ExecutorService.invokeAll(tasks) termina normalmente, os objetos Future já estão num estado final e seguem a ordem das tarefas na coleção. isDone() não significa sucesso: é get() no Future da tarefa, e não invokeAll, que comunica a exceção da tarefa como ExecutionException. A própria chamada a invokeAll pode ser interrompida durante a espera (InterruptedException) ou não conseguir agendar uma tarefa (RejectedExecutionException). A sobrecarga de invokeAll com limite de tempo cancela as tarefas por concluir antes de devolver o controlo; get() num Future cancelado lança CancellationException.
Exemplos
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
A primeira linha mostra que `invokeAll` devolveu o controlo normalmente. O primeiro `get()` devolve `42`; o segundo lança `ExecutionException`. O programa apresenta o tipo e a mensagem da causa, não os da exceção que a encapsula. O bloco try-with-resources fecha o executor.
Lições relacionadas
- Java · Lição 50 · Intermédio · Versão: 2