Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

ExecutorService — tâches, résultats et arrêt

ExecutorService sépare la soumission des tâches de la gestion de leur exécution. Découvrez submit, l’exécution groupée avec invokeAll et shutdown, ainsi que la différence entre demander l’arrêt et attendre la fin effective.

Version : Java SE 21 (repository runtime); production runtime not attested

Syntaxe

<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 étend Executor en ajoutant le suivi des résultats et la gestion de la fin d’exécution. Cette fiche concerne Java SE 21, l’environnement d’exécution du dépôt. L’environnement d’exécution en production n’est pas attesté.

ExecutorService.submit renvoie un Future : pour Callable<T>, il fournit le résultat de la tâche ; pour Runnable, le résultat est null ; et pour submit(Runnable, T), il s’agit de la valeur fournie. Future.get() attend si nécessaire ; il signale l’échec d’une tâche avec ExecutionException, l’annulation avec CancellationException et une interruption pendant l’attente avec InterruptedException.

ExecutorService.invokeAll sans délai d’attente attend que toutes les tâches Callable soient terminées. Les futures renvoyés conservent l’ordre d’entrée, et non l’ordre d’achèvement. La fin d’exécution ne signifie pas que la tâche a réussi : récupérez résultats et erreurs avec get().

ExecutorService.shutdown refuse les nouvelles tâches, permet l’exécution de celles déjà acceptées et n’attend pas. Utilisez awaitTermination pour attendre ; en Java SE 21, close() dans try-with-resources arrête le service et attend. L’appel explicite à shutdown() dans l’exemple illustre l’API, mais est redondant à cause de close(). Les tâches longues peuvent retarder la fermeture.

L’exemple utilise Executors.newFixedThreadPool(2). Cette fabrique possède une file d’attente non bornée : deux threads ne limitent pas le nombre de tâches en attente. Ne la considérez pas comme une protection automatique contre la surcharge.

Exemples

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());
            }
        }
    }
}

Résultat

42
5
20

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources