Leçons

Dans ce cours, nous expliquons ce qu’est l’interblocage des threads (deadlock) en Java, pourquoi il survient et quelles sont les quatre conditions nécessaires. À l’aide d’un exemple pratique avec synchronized, nous montrons comment reproduire le problème, puis nous étudions des stratégies de prévention : ordre unique de prise des ressources, utilisation de ReentrantLock.tryLock avec délai d’attente, réduction des sections critiques et abandon des verrous imbriqués inutiles. Nous montrerons le diagnostic via Thread Dump et jstack, comment reconnaître les états BLOCKED/ WAITING, et nous terminerons par une liste de contrôle et des erreurs typiques.

Nous analysons les anomalies de concurrence Livelock et Starvation : en quoi elles diffèrent de Deadlock, à quoi elles ressemblent dans le code et dans les logs. Des exemples en Java sont présentés : « travailleurs polis » (blocage vivant) et affamement dû aux priorités et aux verrous non équitables. Nous apprenons à détecter le problème (journalisation, Thread dump, VisualVM, Java Mission Control) et à le prévenir : retards aléatoires avant une nouvelle tentative ( Thread.sleep), algorithmes non bloquants, verrous équitables via ReentrantLock avec le drapeau fairness ( new ReentrantLock(true)), sections critiques soignées et éviter l’abus de setPriority() et de synchronized.

Dans ce cours, nous verrons pourquoi les collections classiques ( ArrayList, HashMap) sont dangereuses en environnement multithread, et quelles alternatives thread-safe propose le package java.util.concurrent : ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, des structures basées sur des skip lists et BlockingQueue. Nous discuterons des opérations atomiques comme merge, putIfAbsent, computeIfAbsent, nous les comparerons à Collections.synchronizedMap, et nous examinerons des exemples pratiques ainsi que les erreurs typiques (itérateurs à cohérence faible, séquences d’opérations non atomiques, etc.).

Pourquoi l’incrément i ++ ne fonctionne pas en environnement multithread, ce que sont les opérations atomiques et comment le package java.util.concurrent.atomic les fournit. Nous étudions AtomicInteger et AtomicReference, les méthodes incrementAndGet(), compareAndSet(...), le mécanisme interne CAS (Compare-And-Swap), ainsi que quand il vaut mieux choisir synchronized et quand — LongAdder. Pour finir — erreurs typiques : opérations complexes, ABA et sécurité des threads des objets imbriqués.

Comment prendre et lire un Thread Dump à l’aide de jstack, de VisualVM et de l’IDE, reconnaître les états des threads ( RUNNABLE, BLOCKED, WAITING) et détecter les interblocages. Nous examinerons la surveillance des threads dans Java Mission Control et Java Flight Recorder, les pratiques de journalisation (noms des threads, entrée/sortie des blocs synchronized), la minimisation des verrous, les tests de concurrence avec CountDownLatch et l’analyse d’un cas réel de deadlock. Pour finir — erreurs typiques et comment les éviter.

Dans ce cours, nous expliquons la différence entre le multithreading et le parallélisme : quand la réactivité est importante, et quand il s’agit d’une accélération réelle sur plusieurs cœurs. Nous aborderons la création de threads via Thread, l’implémentation de Runnable et les pools de haut niveau ExecutorService, nous verrons un exemple simple de somme d’un tableau, nous analyserons quand le parallélisme aide et quand il gêne, ainsi que les problèmes typiques : conditions de course, synchronisation via synchronized, interblocages et équilibrage de charge. À la fin — un tableau comparatif et une visualisation des scénarios.

La programmation concurrente en pratique, version professionnelle : nous confions les tâches à ExecutorService au lieu de créer des Thread manuellement, nous gérons le pool, la file d’attente et le cycle de vie ( shutdown(), shutdownNow()). Nous examinons la différence entre Runnable et Callable<T>, récupérons les résultats via Future et ses méthodes ( get(), isDone(), cancel(...), isCancelled()). Nous montrerons le lancement de plusieurs tâches, invokeAll/ invokeAny, le traitement d’ ExecutionException et les erreurs typiques.

Voyons comment basculer un flux de données classique vers un traitement parallèle en une seule ligne — via parallelStream() ou .parallel(), ce qui se passe sous le capot dans ForkJoinPool.commonPool(), quand le parallélisme accélère réellement les calculs (grandes collections, opérations « lourdes ») et où il peut ralentir. Nous montrerons des exemples de filtrage, d’agrégation, de tri, de mesure de performance et analyserons les erreurs typiques : effets de bord dans forEach, préservation de l’ordre, choix des collections et réglage du degré de parallélisme.

Guide pratique des calculs parallèles en Java : comment fonctionne le pool de tâches ForkJoinPool et les tâches récursives RecursiveTask<T>/ RecursiveAction, en quoi l’algorithme de work-stealing est utile, comment découper les tâches via fork() et agréger les résultats avec join() à l’intérieur de compute(). Nous verrons le lancement via pool.invoke(), un exemple de somme d’un tableau et de recherche du maximum, la place de ForkJoinPool dans parallelStream(), ainsi que les erreurs typiques et comment les éviter.

Guide pratique de la programmation parallèle en Java : quand utiliser ExecutorService, où parallelStream aide, et pour quelles tâches ForkJoinPool est nécessaire. Nous discuterons de la sécurité des threads avec ConcurrentHashMap/ CopyOnWriteArrayList et des classes atomiques ( AtomicInteger), des mesures de performance via System.nanoTime() et JMH, de la gestion des erreurs provenant de Future.get() et ForkJoinTask, de la réaction correcte à InterruptedException, ainsi que des techniques de journalisation ( Thread.currentThread().getName()) et de test ( Awaitility). À la fin — un tableau d’aide au choix de l’outil et les erreurs typiques.

Nous analysons le lancement et la composition de calculs asynchrones avec CompletableFuture : comment démarrer des tâches via supplyAsync et runAsync, en quoi diffèrent les gestionnaires thenApply, thenAccept, thenRun, et quand choisir leurs versions asynchrones thenApplyAsync/ thenAcceptAsync/ thenRunAsync. Nous parlerons des threads d’exécution ( ForkJoinPool ou votre Executor), des types de résultats ( CompletableFuture<T>, CompletableFuture<Void>) et des erreurs courantes : appels bloquants get()/ join(), erreurs non traitées sans exceptionally/ handle/ whenComplete, ainsi que la tentative d’utiliser le résultat à l’intérieur de thenRun.