Cum funcționează multithreading în Java?

Question

Accepted Answer

**Multithreading** permite unui program Java să ruleze mai multe fire de execuție simultan, permițând paralelism (utilizarea mai multor nuclee CPU) și responsivitate (execuția lucrării fără blocare). Java are suport de prim rang pentru fire de execuție — dar starea comună mutabilă introduce complexitate (race conditions) care trebuie gestionată cu grijă. ## Crearea firelor de execuție ```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); ``` **Capcană majoră:** apelează `start()` (creează un nou fir de execuție), nu `run()` (care doar execută codul pe firul curent sincron). ## Problema de bază: race conditions ```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++` sunt de fapt trei operații (citire, increment, scriere). Când firele se intercalează, actualizările se pierd — o **race condition**. Aceasta este provocarea centrală a concurenței: stare comună mutabilă accesată de mai multe fire fără coordonare. ## Soluții pentru stare comună sigură ```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) ``` ## Coordonarea firelor de execuție ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Abordarea modernă: nu gestiona fire brute ```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 ``` ## De ce este important Multithreading permite programelor Java să utilizeze mai multe nuclee și să rămână responsive, dar este și una dintre cele mai dificile domenii de a face corect — **race conditions** din starea comună mutabilă nesincronizată cauzeaza erori intermitente, greu de reprodus. Înțelegerea modului în care funcționează firele (`start()` vs `run()`), problema de bază a race conditions (de ce `count++` nu este sigur) și instrumentele pentru a asigura siguranța (`synchronized`, clase atomice, colecții concurente, imutabilitate) este esențială pentru a scrie cod concurrent corect. Practica modernă favorizează abstractizări de nivel superior (ExecutorService, CompletableFuture, fire virtuale) în locul gestionării directe a firelor brute. Aceasta este cunoștință critică pentru Java de server și de performanță înaltă, și un subiect profund și frecvent testat care deosebește dezvoltatorii competenți de cei experți.