Come funziona il multithreading in Java?

Question

Accepted Answer

**Multithreading** consente a un programma Java di eseguire più thread contemporaneamente, abilitando parallelismo (utilizzando più core della CPU) e responsività (eseguendo lavoro senza bloccarsi). Java ha supporto di primo livello per i thread — ma lo stato mutabile condiviso introduce complessità (race condition) che deve essere gestita attentamente. ## Creazione di thread ```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); ``` **Gotcha importante:** chiama `start()` (avvia un nuovo thread), non `run()` (che esegue semplicemente il codice sul thread corrente in modo sincrono). ## Il problema centrale: race condition ```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++` è in realtà tre operazioni (lettura, incremento, scrittura). Quando i thread si intercalano, gli aggiornamenti vanno persi — una **race condition**. Questo è il sfida centrale della concorrenza: lo stato mutabile condiviso accessibile da più thread senza coordinamento. ## Soluzioni per lo stato condiviso sicuro ```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) ``` ## Coordinamento dei thread ```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'approccio moderno: non gestire thread grezzi ```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 ``` ## Perché è importante Il multithreading consente ai programmi Java di utilizzare più core e rimanere responsivi, ma è anche una delle aree più difficili da implementare correttamente — le **race condition** dello stato mutabile condiviso non sincronizzato causano bug intermittenti e difficili da riprodurre. Comprendere come funzionano i thread (`start()` vs `run()`), il problema centrale di race condition (perché `count++` non è sicuro), e gli strumenti per garantire la sicurezza (`synchronized`, classi atomiche, collezioni concorrenti, immutabilità) è essenziale per scrivere codice concorrente corretto. La best practice moderna favorisce astrazioni di livello superiore (ExecutorService, CompletableFuture, virtual thread) rispetto alla gestione diretta dei thread. Questa è una conoscenza critica per Java lato server e ad alte prestazioni, e un argomento profondo e frequentemente testato che separa gli sviluppatori competenti da quelli esperti.