Leçons

Nous expliquons pourquoi le ThreadLocal classique perd de sa pertinence dans le monde des threads virtuels, et comment ScopedValue le remplace : un contexte attaché à la portée d’exécution, et non au thread. Des exemples pas à pas de propagation du contexte (utilisateur, REQUEST_ID), des scopes imbriqués et leur masquage, l’intégration avec les threads virtuels ( Executors. newVirtualThreadPerTaskExecutor()). Nous discutons la comparaison ThreadLocal vs ScopedValue, des conseils pratiques, des limites et un aperçu de Structured Concurrency (preview).

Structured Concurrency transforme un ensemble chaotique de threads en une hiérarchie de tâches maîtrisée : vous lancez des sous-tâches dans des threads virtuels à l’intérieur de StructuredTaskScope, vous les attendez via join(), vous traitez les erreurs de façon centralisée avec throwIfFailed() et vous récupérez les résultats avec resultNow()/ result(). Nous examinerons les politiques de terminaison ShutdownOnFailure et ShutdownOnSuccess, les comparerons à CompletableFuture, verrons des exemples d’agrégateur HTTP et les erreurs typiques lors de l’utilisation de la concurrence structurée.

Comment annuler correctement des opérations longues et bloquantes en Java : interruption coopérative via Thread.interrupt(), annulation des tâches via Future.cancel() et comportement de CancellationException, délais d’expiration (timeouts) et annulation dans CompletableFuture ( orTimeout, completeOnTimeout), concurrence structurée avec StructuredTaskScope, deadline commune (budget de temps) et propagation des délais d’expiration vers le bas de la pile (y compris Instant/ Duration et Scoped Values). Nous passons en revue la pratique avec des E/S bloquantes et les erreurs typiques.

Dans ce cours, nous passons en revue les synchroniseurs de haut niveau de java.util.concurrent : CountDownLatch, CyclicBarrier, Phaser et Exchanger. Nous apprenons à coordonner le démarrage et la fin des tâches via await()/ countDown(), à construire des phases réutilisables et des actions de barrière avec await(), à gérer des participants dynamiques de « orchestre » avec register()/ arriveAndAwaitAdvance()/ arriveAndDeregister() et à échanger des données par paires via exchange(). En pratique, nous mettrons en œuvre un départ massif de workers et un « tick » de jeu, et nous analyserons aussi les erreurs typiques : le caractère à usage unique de CountDownLatch, le traitement de BrokenBarrierException et un deregister() correct. Partout, nous nous passons de la douleur de wait()/ notify().

Lorsque ReentrantReadWriteLock et le ReadWriteLock classique commencent à caler sous forte charge, StampedLock vient à la rescousse avec la lecture optimiste : le duo tryOptimisticRead + validate offre des lectures presque « gratuites » lorsque les écritures sont rares. Nous passerons en revue les modes de verrouillage, le travail avec les stamps (jetons), les limites en matière de réentrance, nous comparerons avec ReentrantReadWriteLock, et nous verrons aussi des compteurs à faible contention — LongAdder et LongAccumulator — et pourquoi ils dépassent AtomicLong en situation de concurrence. Nous terminerons par de la pratique : un cache à dominante lecture et un mini-benchmark.

Nous analysons les règles de visibilité et d’ordonnancement des opérations dans la Java Memory Model : ce que signifie la relation happens-before, comment et quand volatile, synchronized, les champs finaux ( final) aident, et pourquoi sans eux on obtient des données « obsolètes ». Nous montrerons la publication sûre des objets, un double-checked locking correct, l’accès bas niveau via VarHandle, l’impact du faux partage et l’annotation @Contended, ainsi que des remarques pratiques sur Thread.start()/ Thread.join(), Future.get() et les microbenchmarks JMH.

Guide pratique pour le travail parallèle avec des fichiers en Java: quand le multithreading accélère réellement les E/S et quand ce n’est pas le cas, choix des outils — Thread, pool de threads via ExecutorService, asynchronisme avec CompletableFuture et flux parallèles — ainsi que lecture de gros fichiers par morceaux via FileChannel, écriture sûre dans un journal partagé et limites de l’OS/FS. Nous passons en revue les modèles de démarrage des tâches, la configuration des pools, les méthodes shutdown()/ awaitTermination() et les erreurs typiques.

Guide pratique pour paralléliser des tâches sur fichiers en Java: comment activer le parallélisme dans l’ Stream API avec la méthode parallel()/ parallelStream(), comment fonctionne et se configure le ForkJoinPool, et quand il vaut mieux utiliser RecursiveTask. Nous verrons où le parallélisme accélère réellement les E/S, comment gérer le pool de threads commun, et comment fermer les ressources en toute sécurité ( try-with-resources). Pour finir — un rapide aperçu de l’accès positionnel via FileChannel pour lire/écrire des portions de gros fichiers.

Comment accélérer le parcours de grands répertoires et le traitement de milliers de fichiers : nous utilisons Files.walk() et des streams parallèles via parallel(), nous comprenons le rôle de ForkJoinPool.commonPool() et nous réglons le degré de parallélisme. Nous voyons quand il vaut mieux passer à ExecutorService, en quoi les tâches CPU-bound et IO-bound diffèrent, nous écrivons un exemple de comptage des lignes dans tous les fichiers ".java" et fixons les bonnes pratiques.

Comment accélérer le traitement de fichiers de plusieurs gigaoctets : on les découpe en chunks (chunking), on utilise l’accès positionnel via FileChannel et des buffers mappés en mémoire MappedByteBuffer, on parallélise les calculs avec ExecutorService. Passons en revue les méthodes clés de l’E/S positionnée : position(...), read(...), write(...), les critères de choix de la taille de chunk, un exemple de comptage de mots en parallèle et les erreurs typiques (frontières des chunks, ressources, nombre de threads).

Nous expliquons comment organiser un pipeline de traitement de fichiers selon le patron Producer–Consumer avec un échange sécurisé via BlockingQueue (par exemple, ArrayBlockingQueue), comment fonctionnent les opérations bloquantes put() et take(), pourquoi le mécanisme de backpressure est nécessaire et comment terminer correctement les threads à l’aide d’une « poison pill » (par exemple, "__END__", et non null). Nous lançons les consommateurs via ExecutorService, ajoutons une visualisation du pipeline et passons en revue les erreurs typiques.

Nous expliquons pourquoi Java 9 a apporté le système de modules JPMS : en quoi la « classpath-party » pose problème, comment les modules introduisent des frontières de visibilité au niveau du conteneur, ce qu’est module-info.java et comment travailler avec les directives module, exports, requires, opens, uses/ provides. Nous discuterons des avantages (encapsulation, dépendances explicites, sécurité, jlink), des cas d’usage (y compris java.base, java.sql), des subtilités utiles et des erreurs typiques lors d’une migration (un exports oublié, un requires manquant, des doublons de noms de modules).