CKTIS / Java
ExecutorService — attività, risultati e arresto
ExecutorService separa l’invio delle attività dalla gestione della loro esecuzione. Scopri submit, l’esecuzione in blocco con invokeAll e shutdown, e la differenza tra richiedere l’arresto e attenderne il completamento.
Versione: Java SE 21 (repository runtime); production runtime not attested
Sintassi
<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 aggiungendo il monitoraggio dei risultati e la gestione della terminazione. Questa voce riguarda Java SE 21, l’ambiente di esecuzione del repository. L’ambiente di esecuzione in produzione non è confermato.
ExecutorService.submit restituisce un Future: per Callable<T> fornisce il risultato dell’attività, per Runnable il risultato è null e per submit(Runnable, T) è il valore fornito. Future.get() attende se necessario; segnala un errore dell’attività con ExecutionException, l’annullamento con CancellationException e un’interruzione durante l’attesa con InterruptedException.
ExecutorService.invokeAll senza timeout attende che tutte le attività Callable terminino. I future restituiti mantengono l’ordine di input, non quello di completamento. Il completamento non implica il successo: recupera risultati ed errori tramite get().
ExecutorService.shutdown rifiuta nuove attività, consente l’esecuzione di quelle già accettate e non attende. Per attendere, usa awaitTermination; in Java SE 21, close() in try-with-resources arresta il servizio e attende. La chiamata esplicita a shutdown() nell’esempio mostra l’API, ma è ridondante grazie a close(). Le attività di lunga durata possono ritardare la chiusura.
L’esempio usa Executors.newFixedThreadPool(2). Questa factory ha una coda illimitata: due thread non limitano il numero di attività in attesa. Non considerarla una protezione automatica dal sovraccarico.
Esempi
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());
}
}
}
}Risultato
42 5 20
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.