Formations — 1 037 leçons en français

Accueil › Java › Exécuteurs et résultats asynchrones

Exécuteurs et résultats asynchrones

La concurrenceintermediaire

Créer un Thread à la main pour chaque tâche est coûteux (création, mémoire) et ne dimensionne pas le nombre de threads simultanés : sous forte charge, rien n'empêche d'en créer des milliers. Un ExecutorService gère un pool de threads réutilisés et une file d'attente de tâches.

ExecutorService executeur = Executors.newFixedThreadPool(4);
Future<Integer> resultat = executeur.submit(() -> calculerTotalCommande(id)); // Callable<Integer>
int total = resultat.get(5, TimeUnit.SECONDS); // bloque, avec un délai maximal
executeur.shutdown();

submit() renvoie toujours un Future (contrairement à execute(), qui ne renvoie rien) : une exception dans la tâche y est capturée, invisible tant que personne n'appelle get(). Dimensionner un pool dépend du type de tâche : proche du nombre de cœurs pour du calcul, bien plus large pour des tâches qui attendent (réseau, disque).

CompletableFuture permet de composer des traitements asynchrones sans bloquer sur get() à chaque étape :

CompletableFuture
    .supplyAsync(() -> chargerCommande(id))
    .thenApply(Commande::total)
    .exceptionally(ex -> 0)
    .thenAccept(total -> System.out.println("Total : " + total));

Arrêter un ExecutorService proprement demande un enchaînement explicite : shutdown(), puis awaitTermination(), avec shutdownNow() en dernier recours.

Les termes à connaître

ExecutorService

Abstraction de haut niveau pour exécuter des tâches (Runnable, Callable<T>) sur un pool de threads géré, sans créer les threads soi-même. Fournit submit (renvoie un Future), invokeAll, et un arrêt contrôlé (shutdown, shutdownNow).

Future<T>

Représente le résultat futur d'une tâche soumise. get() bloque jusqu'à disponibilité du résultat (ou lève l'exception survenue dans la tâche, enveloppée dans ExecutionException) ; get(delai, unite) évite un blocage indéfini ; cancel(boolean) tente d'annuler la tâche.

submit vs execute

execute(Runnable) (interface Executor) lance une tâche sans rien renvoyer : une exception non capturée y est perdue dans le gestionnaire d'exceptions par défaut du thread. submit(...) (interface ExecutorService) renvoie toujours un Future, qui capture le résultat ou l'exception — récupérable seulement en appelant get().

shutdown / shutdownNow / awaitTermination

shutdown() refuse les nouvelles tâches mais laisse terminer celles en cours et en attente. shutdownNow() tente d'interrompre les tâches en cours et renvoie celles qui n'ont pas démarré. awaitTermination(delai, unite) bloque jusqu'à l'arrêt effectif ou l'expiration du délai — l'arrêt propre standard enchaîne shutdown() puis awaitTermination(), avec shutdownNow() en repli.

ScheduledExecutorService

Variante d'ExecutorService qui planifie l'exécution différée ou périodique de tâches : schedule (une fois, après un délai), scheduleAtFixedRate (période fixe entre débuts), scheduleWithFixedDelay (délai fixe entre la fin d'une exécution et le début de la suivante).

CompletableFuture

Future enrichi qui se compose sans bloquer : thenApply transforme le résultat, thenCompose l'enchaîne avec un autre CompletableFuture (évite l'imbrication), thenCombine combine deux résultats indépendants, allOf/anyOf attendent plusieurs futures, exceptionally/handle traitent les erreurs sans bloquer sur get().

Dimensionnement d'un pool

Pour des tâches limitées par le processeur (calcul), une taille proche du nombre de cœurs disponibles (Runtime.getRuntime().availableProcessors()) maximise le débit sans sur-solliciter le CPU. Pour des tâches limitées par les entrées/sorties (attente réseau, disque), un pool bien plus grand que le nombre de cœurs reste utile, car les threads passent le plus clair de leur temps bloqués, pas à calculer.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.