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

CKTIS / Java

ExecutorService — tarefas, resultados e encerramento

ExecutorService separa a submissão de tarefas da gestão da sua execução. Aprenda a usar submit, a execução em lote com invokeAll e shutdown, e a diferença entre pedir o encerramento e aguardar pela conclusão.

Versão: Java SE 21 (repository runtime); production runtime not attested

Sintaxe

<T> Future<T> submit(Callable<T> task)
Future<?> submit(Runnable task)
<T> Future<T> submit(Runnable task, T result)
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
void shutdown()

java.util.concurrent.ExecutorService estende Executor, acrescentando o acompanhamento de resultados e a gestão da terminação. Esta entrada diz respeito ao Java SE 21, o ambiente de execução do repositório. O ambiente de execução em produção não está confirmado.

ExecutorService.submit devolve um Future: para Callable<T>, fornece o resultado da tarefa; para Runnable, o resultado é null; e, para submit(Runnable, T), é o valor fornecido. Future.get() aguarda, se necessário; comunica uma falha da tarefa através de ExecutionException, o cancelamento através de CancellationException e uma interrupção durante a espera através de InterruptedException.

ExecutorService.invokeAll sem limite de tempo aguarda que todas as tarefas Callable terminem. Os futures devolvidos mantêm a ordem de entrada, não a ordem de conclusão. A conclusão não implica sucesso: obtenha os resultados e os erros através de get().

ExecutorService.shutdown rejeita novas tarefas, permite a execução das que já foram aceites e não aguarda. Para aguardar, utilize awaitTermination; no Java SE 21, close() em try-with-resources encerra o serviço e aguarda. O shutdown() explícito no exemplo demonstra a API, mas é redundante devido a close(). Tarefas longas podem atrasar o encerramento.

O exemplo utiliza Executors.newFixedThreadPool(2). Esta fábrica tem uma fila ilimitada: dois threads não limitam o número de tarefas em espera. Não a considere uma proteção automática contra sobrecarga.

Exemplos

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
            Future<Integer> single = pool.submit(() -> 6 * 7);
            List<Callable<Integer>> tasks = List.of(() -> 2 + 3, () -> 4 * 5);
            List<Future<Integer>> batch = pool.invokeAll(tasks);
            pool.shutdown();

            System.out.println(single.get());
            for (Future<Integer> result : batch) {
                System.out.println(result.get());
            }
        }
    }
}

Resultado

42
5
20

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes