Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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, TimeoutException

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

Fontes