Comment fonctionne le multithreading en Java ?

Question

Accepted Answer

**Multithreading** permet à un programme Java d'exécuter plusieurs threads de manière concurrente, permettant le parallélisme (utilisation de plusieurs cœurs CPU) et la réactivité (exécution de tâches sans blocage). Java a un support de threads de première classe — mais l'état partagé mutable introduit de la complexité (conditions de course) qui doit être gérée avec attention. ## Créer des threads ```java // 1. Implement Runnable (preferred — separates task from thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() runs it on a NEW thread (run() would run on the CURRENT thread!) // 2. modern: use an ExecutorService instead of raw threads ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Piège clé :** appelez `start()` (crée un nouveau thread), pas `run()` (qui exécute simplement le code sur le thread courant de manière synchrone). ## Le problème fondamental : les conditions de course ```java // ❌ multiple threads modifying shared state → unpredictable results class Counter { int count = 0; void increment() { count++; } // NOT atomic: read → add → write (can interleave) } // 1000 threads each incrementing 1000 times → final count is often < 1,000,000! ``` `count++` est en réalité trois opérations (lecture, incrémentation, écriture). Quand les threads s'entrelacent, les mises à jour sont perdues — une **condition de course**. C'est le défi central de la concurrence : un état partagé mutable accédé par plusieurs threads sans coordination. ## Solutions pour un état partagé sûr ```java // 1. synchronized — only one thread in the method/block at a time (a lock) synchronized void increment() { count++; } // 2. atomic classes — lock-free atomic operations AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // atomic, thread-safe, efficient // 3. concurrent collections — built for multi-threaded access ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt) ``` ## Coordination de threads ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## L'approche moderne : ne pas gérer les threads bruts ```text ✓ Use ExecutorService / thread pools (not new Thread() per task — expensive) ✓ Use CompletableFuture for async composition ✓ Use concurrent collections and atomic classes over manual synchronization ✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency ``` ## Pourquoi c'est important Le multithreading permet aux programmes Java d'utiliser plusieurs cœurs et de rester réactifs, mais c'est aussi l'un des domaines les plus difficiles à bien maîtriser — les **conditions de course** dues à un état partagé mutable non synchronisé causent des bugs intermittents, difficiles à reproduire. Comprendre comment fonctionnent les threads (`start()` vs `run()`), le problème fondamental de condition de course (pourquoi `count++` n'est pas sûr), et les outils pour assurer la sécurité (`synchronized`, classes atomiques, collections concurrentes, immuabilité) est essentiel pour écrire du code concurrent correct. La meilleure pratique moderne privilégie les abstractions de plus haut niveau (ExecutorService, CompletableFuture, virtual threads) par rapport à la gestion brute des threads. C'est une connaissance critique pour Java côté serveur et haute performance, et un sujet profondément testé qui distingue les développeurs compétents des experts.