Java Concurrency in Practice

Introduction

Le livre «Java Concurrency in Practice» (auteurs : Brian Goetz, Tim Peierls, Joshua Bloch et al.) est, sans exagération, la bible de la programmation multithread en Java. Publié en 2006, il reste à ce jour la source la plus autorisée et la plus approfondie sur le parallélisme dans l'écosystème Java. Bien que près de deux décennies se soient écoulées depuis sa publication, les principes fondamentaux décrits dans le livre n'ont pas vieilli : le modèle mémoire Java (JMM), les problèmes de visibilité, d'atomicité, d'ordonnancement, ainsi que les modèles de publication sécurisée d'objets restent pertinents aujourd'hui.

Ce livre n'est pas une introduction à Java pour débutants — il suppose une maîtrise solide du langage et une compréhension de base des threads. Cependant, c'est précisément lui qui transforme un développeur d'« utilisateur de threads » en un véritable expert, capable de concevoir des applications fiables, évolutives et thread-safe.

De quoi parle ce livre

«Java Concurrency in Practice» couvre tous les aspects clés de la programmation parallèle en Java — des mécanismes de synchronisation de bas niveau aux abstractions de haut niveau du package java.util.concurrent. Le livre est structuré logiquement : il explique d'abord les problèmes fondamentaux du multithreading (conditions de course, interblocages, problèmes de visibilité), puis examine les outils pour les résoudre — synchronized, volatile, final, variables atomiques, verrous ReentrantLock, sémaphores, barrières. Des chapitres distincts sont consacrés aux tests de code multithread, aux performances et à l'évolutivité, ainsi qu'à des sujets avancés comme Fork-Join et CompletionService.

Une attention particulière est accordée au modèle mémoire Java (JMM) — c'est la compréhension de la JMM qui permet au développeur d'éviter des erreurs difficiles à détecter liées au réordonnancement des instructions et à la mise en cache des données. Le livre contient de nombreux exemples de code « correct » et « incorrect », ce qui rend le matériel clair et pratique.

À qui s'adresse ce livre

Ce livre est destiné aux développeurs Java expérimentés qui ont déjà rencontré le multithreading et souhaitent systématiser leurs connaissances. Il sera utile :

• Aux développeurs d'applications serveur (services web, traitement de requêtes, files d'attente de tâches) ;
• Aux spécialistes des systèmes à forte charge et des applications à faible latence ;
• Aux architectes concevant des systèmes évolutifs ;
• À ceux qui se préparent à des entretiens techniques (notamment dans les entreprises FAANG) ;
• Aux enseignants et auteurs de cours Java.

Pour les débutants, le livre peut sembler difficile — il est recommandé d'acquérir d'abord les bases du multithreading via d'autres sources (par exemple, «Thinking in Java» de Bruce Eckel ou les tutoriels officiels d'Oracle).

Ce que le lecteur apprendra

• Les problèmes fondamentaux du multithreading : conditions de course, interblocages, famine, inversion de priorité.
• La sécurité des threads : comment concevoir des classes qui fonctionnent correctement lorsqu'elles sont accédées par plusieurs threads.
• Le modèle mémoire Java (JMM) : règles happens-before, garanties de visibilité, d'atomicité et d'ordonnancement.
• La publication sécurisée d'objets : comment rendre un objet visible pour d'autres threads sans compromettre l'intégrité.
• Les outils de synchronisation : synchronized, volatile, ReentrantLock, ReadWriteLock, StampedLock.
• Les classes atomiques : AtomicInteger, AtomicReference, AtomicLong, AtomicReferenceFieldUpdater.
• Les pools de threads et Executor : ThreadPoolExecutor, ScheduledThreadPoolExecutor, ForkJoinPool.
• Les collections pour le multithreading : ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, ConcurrentLinkedQueue.
• Les tests de code multithread : comment écrire des tests qui détectent les courses et les blocages (y compris l'utilisation de Thread.yield() et des primitives de synchronisation).