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.