Leçons

Comment paralléliser des tâches et fusionner des résultats à l’aide de CompletableFuture : fusion de deux résultats avec thenCombine/ thenCombineAsync, attente d’un ensemble de tâches avec allOf, réaction à la première réponse avec anyOf. Nous passerons en revue les signatures, des exemples pratiques avec supplyAsync, le traitement non bloquant ( thenAccept, thenRun), ainsi que les subtilités des erreurs et leur gestion ( exceptionally, handle, whenComplete). À la fin — un tableau comparatif compact des méthodes.

Comment intercepter et traiter en toute sécurité les exceptions dans les chaînes CompletableFuture : nous détaillons les rôles de exceptionally (valeur de secours en cas d’erreur), handle (gestionnaire universel réussite/erreur) et whenComplete (effets secondaires sans modifier le résultat). Nous verrons pourquoi un appel direct à get()/ join() encapsule la cause dans ExecutionException/ CompletionException, comment combiner les étapes ( thenApply, thenAccept) et quelles erreurs courantes éviter.

Comment « assembler » correctement des étapes asynchrones dans CompletableFuture avec thenCompose et quand thenApply suffit ; comment et pourquoi brancher un pool de threads dédié via ExecutorService (au lieu de ForkJoinPool.commonPool()) ; comment protéger les chaînes contre l’« attente infinie » avec orTimeout et completeOnTimeout. À la fin — un exemple pratique avec un Executor personnalisé, thenCompose et un délai d’expiration, ainsi que des erreurs typiques et leurs solutions.

Dans ce cours, nous abordons les entrées/sorties asynchrones (AIO) dans Java NIO.2 : en quoi elles diffèrent de l’I/O synchrone, comment travailler avec AsynchronousFileChannel, lancer des opérations de lecture/écriture via Future et CompletionHandler, ainsi que l’impact du choix du pool de threads ExecutorService. En pratique, nous verrons l’ouverture du canal via open, les méthodes read/ write, le schéma d’interaction et les erreurs fréquentes.

Comment, en Java, gérer l’achèvement des opérations asynchrones NIO.2 : des « promesses » via Future et des callbacks via CompletionHandler. Nous examinerons les signatures read/ write d’ AsynchronousFileChannel, l’obtention bloquante du résultat via get() et le sondage isDone(), ainsi que le traitement non bloquant dans completed()/ failed(). Nous montrerons des exemples pratiques de lecture/écriture et une brève comparaison des approches.

Nous pratiquons l’E/S asynchrone en Java : lecture de gros fichiers texte par blocs dans ByteBuffer via AsynchronousFileChannel, conversion correcte des octets en caractères avec CharsetDecoder, écriture des données de manière asynchrone (via Future ou CompletionHandler). Nous analysons le problème des coupures de caractères multioctets (par exemple "UTF-8"), le comptage des lignes à la volée, le choix des encodages et les erreurs courantes lors de l’utilisation des tampons et des canaux.

Comment intercepter et gérer correctement les erreurs dans les E/S asynchrones de Java: callbacks CompletionHandler avec les méthodes completed/ failed, journalisation et notifications. Nous examinons l’annulation des opérations via Future et cancel( boolean), les conséquences pour get() et CancellationException, ainsi que des conseils pratiques: try-with-resources, synchronisation avec CountDownLatch/ CompletableFuture et libération des ressources.

Analyse pratique des pièges lors de l’E/S de fichiers asynchrone avec Java NIO : gestion correcte des tampons ByteBuffer (propriétés position/ limit, appels à flip(), clear(), compact()), conditions de course lors d’opérations parallèles avec AsynchronousFileChannel, fermeture des ressources ( channel.close(), try-with-resources), gestion des erreurs dans CompletionHandler (méthode failed(...)), pilotage du cycle de vie des opérations via Future<Integer> et synchronisation avec CountDownLatch, gestion correcte des encodages via CharsetDecoder, ainsi que le choix d’un pool de threads adapté ExecutorService.

Analysons en quoi les threads de plateforme diffèrent des threads virtuels : comment fonctionne le modèle «  Platform Thread → OS » et pourquoi il est lourd, ce qui change avec les threads virtuels ( Virtual Thread) au‑dessus des carrier threads, et comment cela apporte de la scalabilité sans « spaghetti » réactif. Nous verrons la pratique avec Thread.ofVirtual(), comparerons le comportement pour des tâches I/O‑bound et CPU‑bound, aborderons la compatibilité (appels bloquants comme InputStream.read, Socket.accept) et les erreurs typiques (anciens mécanismes de synchronisation, attentes d’une « accélération magique »).

Pratique des threads virtuels de Java 21: en quoi ils diffèrent des threads de plateforme, comment les démarrer via Thread.startVirtualThread(...) et Thread.ofVirtual().start(...), quand new Thread(...) ou Thread.ofPlatform() restent pertinents, et comment exécuter massivement des tâches avec Executors.newVirtualThreadPerTaskExecutor(). Nous verrons l’attente de fin via join(), la gestion des erreurs avec Future et ExecutionException, ainsi que les erreurs typiques lors de l’utilisation des Virtual Threads.

Comparaison pratique entre les threads de plateforme Thread et les threads virtuels de Java 21: comment la JVM, grâce aux « threads porteurs » (carrier threads), exécute des centaines de milliers de tâches avec un minimum de mémoire, où les threads virtuels brillent (I/O-bound) et où ils ne le font pas (CPU-bound). Nous passerons en revue les limitations ( synchronized, verrous natifs), les meilleures pratiques ( Executors.newVirtualThreadPerTaskExecutor()), le monitoring via JVisualVM et Java Flight Recorder, ainsi que les erreurs typiques lors du passage à Virtual Threads.

Nous allons voir comment exécuter une tâche par thread virtuel à l’aide de Executors.newVirtualThreadPerTaskExecutor() (Java 21), en quoi cela diffère des pools classiques ( newFixedThreadPool, newCachedThreadPool), comment arrêter proprement via shutdown() et awaitTermination(...), récupérer les résultats des tâches via Future et où les threads virtuels apportent le plus de gain (I/O massif, serveurs web, tests de charge). Enfin — erreurs typiques et nuances.