Lezioni

In questa lezione analizziamo che cos'è il blocco reciproco dei thread (deadlock) in Java, perché si verifica e quali sono le quattro condizioni necessarie. Con un esempio pratico con synchronized mostriamo come riprodurre il problema, poi studiamo strategie di prevenzione: ordine unico di acquisizione delle risorse, uso di ReentrantLock.tryLock con timeout, riduzione delle sezioni critiche e rinuncia a lock annidati superflui. Mostriamo la diagnostica tramite Thread Dump e jstack, come riconoscere gli stati BLOCKED/ WAITING, e concludiamo con una checklist ed errori tipici.

Analizziamo le anomalie di concorrenza Livelock e Starvation: in cosa differiscono da Deadlock, come appaiono nel codice e nei log. Vengono mostrati esempi in Java: «lavoratori educati» (blocco vivente) e starvation dovuta alle priorità e a lock non equi. Impariamo a individuare il problema (logging, Thread dump, VisualVM, Java Mission Control) e a prevenirlo: ritardi casuali prima del nuovo tentativo ( Thread.sleep), algoritmi non bloccanti, lock equi tramite ReentrantLock con flag di fairness ( new ReentrantLock(true)), sezioni critiche curate e niente abusi di setPriority() e synchronized.

In questa lezione vedremo perché le collezioni normali ( ArrayList, HashMap) sono pericolose in un ambiente multithread e quali alternative thread-safe offre il pacchetto java.util.concurrent: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, strutture basate su skip list e BlockingQueue. Discuteremo operazioni atomiche come merge, putIfAbsent, computeIfAbsent, confronteremo con Collections.synchronizedMap, analizzeremo esempi pratici ed errori tipici (iteratori debolmente consistenti, sequenze di operazioni non atomiche, ecc.).

Perché l'incremento i ++ non funziona nel multithreading, che cosa sono le operazioni atomiche e come le offre il package java.util.concurrent.atomic. Analizziamo AtomicInteger e AtomicReference, i metodi incrementAndGet(), compareAndSet(...), il meccanismo interno CAS (Compare-And-Swap), nonché quando è meglio scegliere synchronized e quando — LongAdder. In chiusura — errori tipici: operazioni complesse, ABA e thread-safety degli oggetti annidati.

Come acquisire e leggere un Thread Dump con jstack, VisualVM e l’IDE, riconoscere gli stati dei thread ( RUNNABLE, BLOCKED, WAITING) e trovare i deadlock. Vedremo il monitoraggio dei thread con Java Mission Control e Java Flight Recorder, pratiche di logging (nomi dei thread, ingresso/uscita da synchronized), minimizzazione dei blocchi, test della concorrenza con CountDownLatch e analisi di un caso reale di deadlock. Infine — errori tipici e come evitarli.

In questa lezione analizziamo la differenza tra multithreading e parallelismo: dove conta la reattività e dove — il reale incremento di velocità su più core. Discuteremo la creazione di thread tramite Thread, l’implementazione di Runnable e i pool di alto livello ExecutorService, vedremo un semplice esempio di somma di un array, capiremo quando il parallelismo aiuta e quando ostacola, nonché i problemi tipici: race condition sui dati, sincronizzazione tramite synchronized, deadlock e bilanciamento del carico. Alla fine — una tabella comparativa e una visualizzazione degli scenari.

Pratica del multithreading in modo serio: passiamo le attività a ExecutorService invece della creazione manuale di Thread, gestiamo il pool, la coda e il ciclo di vita ( shutdown(), shutdownNow()). Analizziamo la differenza tra Runnable e Callable<T>, otteniamo i risultati tramite Future e i suoi metodi ( get(), isDone(), cancel(...), isCancelled()). Mostreremo l'esecuzione di più attività, invokeAll/ invokeAny, la gestione di ExecutionException e gli errori tipici.

Vediamo come passare da un flusso sequenziale all’elaborazione parallela con una sola riga — tramite parallelStream() oppure .parallel(), cosa accade sotto il cofano in ForkJoinPool.commonPool(), quando il parallelismo accelera davvero i calcoli (collezioni grandi, operazioni «pesanti») e dove invece può rallentare. Mostreremo esempi di filtraggio, aggregazione, ordinamento, misurazione delle prestazioni e analizzeremo gli errori tipici: effetti collaterali in forEach, mantenimento dell’ordine, scelta delle collezioni e configurazione del grado di parallelismo.

Guida pratica al calcolo parallelo in Java: come funziona il pool di task ForkJoinPool e i task ricorsivi RecursiveTask<T>/ RecursiveAction, perché è utile l’algoritmo di work-stealing, come suddividere i task con fork() e unire i risultati con join() all’interno di compute(). Vedremo l’avvio tramite pool.invoke(), un esempio di somma di un array e di ricerca del massimo, il ruolo di ForkJoinPool in parallelStream(), nonché gli errori tipici e come evitarli.

Guida pratica alla programmazione parallela in Java: quando conviene usare ExecutorService, dove aiuta parallelStream e per quali compiti serve ForkJoinPool. Discuteremo la thread-safety con ConcurrentHashMap/ CopyOnWriteArrayList e le classi atomiche ( AtomicInteger), le misurazioni delle prestazioni tramite System.nanoTime() e JMH, la gestione degli errori da Future.get() e ForkJoinTask, la corretta reazione a InterruptedException, nonché tecniche di logging ( Thread.currentThread().getName()) e di test ( Awaitility). Alla fine — una tabella di scelta degli strumenti e gli errori tipici.

Analizziamo l’avvio e la composizione di calcoli asincroni con CompletableFuture: come avviare attività tramite supplyAsync e runAsync, in cosa differiscono gli handler thenApply, thenAccept, thenRun e quando scegliere le loro versioni asincrone thenApplyAsync/ thenAcceptAsync/ thenRunAsync. Parleremo dei thread di esecuzione ( ForkJoinPool o un tuo Executor), dei tipi di risultato ( CompletableFuture<T>, CompletableFuture<Void>) e degli errori tipici: chiamate bloccanti get()/ join(), errori non gestiti senza exceptionally/ handle/ whenComplete, nonché il tentativo di usare il risultato all’interno di thenRun.