Lezioni

Analizziamo perché il classico ThreadLocal perde di attualità nel mondo dei thread virtuali e come venga sostituito da ScopedValue: un contesto legato all’ambito di esecuzione, non al thread. Esempi passo-passo di propagazione del contesto (utente, REQUEST_ID), scope annidati e loro sovrapposizione, integrazione con i thread virtuali ( Executors. newVirtualThreadPerTaskExecutor()). Discutiamo il confronto ThreadLocal vs ScopedValue, consigli pratici, limitazioni e uno sguardo a Structured Concurrency (preview).

Structured Concurrency trasforma un insieme caotico di thread in una gerarchia di task controllata: avvii sottoattività in thread virtuali all’interno di StructuredTaskScope, aspetti il loro completamento tramite join(), gestisci gli errori in modo centralizzato con throwIfFailed() e ottieni i risultati con resultNow()/ result(). Analizzeremo le politiche di terminazione ShutdownOnFailure e ShutdownOnSuccess, le confronteremo con CompletableFuture, vedremo esempi di un aggregatore HTTP ed errori tipici nell’uso della concorrenza strutturata.

Come annullare correttamente operazioni lunghe e bloccanti in Java: interruzione cooperativa tramite Thread.interrupt(), annullamento dei task tramite Future.cancel() e comportamento di CancellationException, timeout e annullamento in CompletableFuture ( orTimeout, completeOnTimeout), concorrenza strutturata con StructuredTaskScope, deadline globale (time‑budget) e propagazione dei timeout verso il basso nello stack (inclusi Instant/ Duration e Scoped Values). Analizziamo la pratica con I/O bloccante e gli errori tipici.

Nella lezione analizziamo i sincronizzatori di alto livello di java.util.concurrent: CountDownLatch, CyclicBarrier, Phaser e Exchanger. Impariamo a coordinare l'avvio e la conclusione dei task tramite await()/ countDown(), a costruire fasi riutilizzabili e azioni di barriera con await(), a gestire partecipanti dinamici dell'«orchestra» con register()/ arriveAndAwaitAdvance()/ arriveAndDeregister() e a scambiarci dati a coppie tramite exchange(). In pratica realizzeremo una partenza di massa dei worker e il «tick» di gioco, e vedremo anche gli errori tipici: la natura monouso di CountDownLatch, la gestione di BrokenBarrierException e un deregister() corretto. Ovunque, senza il dolore di wait()/ notify().

Quando ReentrantReadWriteLock e il classico ReadWriteLock iniziano ad arrancare sotto carico elevato, viene in aiuto StampedLock con la lettura ottimistica: la coppia tryOptimisticRead + validate offre letture quasi «gratuite» quando le scritture sono rare. Analizzeremo le modalità di lock, il lavoro con gli «stamp», le limitazioni di reentrancy, confronteremo con ReentrantReadWriteLock, e vedremo anche i contatori a bassa contesa — LongAdder e LongAccumulator — e perché superano AtomicLong in presenza di concorrenza. Concluderemo con la pratica: cache con prevalenza di lettura e un mini‑benchmark.

Analizziamo le regole di visibilità e ordinamento delle operazioni nel Java Memory Model: cosa significa la relazione happens-before, come e quando aiutano volatile, synchronized, i campi final ( final), e perché senza di essi compaiono dati «non aggiornati». Mostreremo la pubblicazione sicura degli oggetti, il double-checked locking corretto, l’accesso a basso livello tramite VarHandle, l’impatto del false sharing e l’annotazione @Contended, nonché note pratiche su Thread.start()/ Thread.join(), Future.get() e i microbenchmark JMH.

Guida pratica al lavoro parallelo con i file in Java: quando il multithreading accelera davvero l’I/O e quando no, scelta degli strumenti — Thread, pool di thread tramite ExecutorService, asincronia con CompletableFuture e stream paralleli — nonché lettura di file di grandi dimensioni a blocchi tramite FileChannel, scrittura sicura in un log condiviso e limiti di SO/FS. Analizziamo i pattern di avvio dei task, la configurazione dei pool, i metodi shutdown()/ awaitTermination() e gli errori tipici.

Guida pratica alla parallelizzazione delle attività sui file in Java: come abilitare il parallelismo nell’ Stream API con i metodi parallel()/ parallelStream(), come funziona e si configura ForkJoinPool e quando conviene usare RecursiveTask. Vedremo dove il parallelismo accelera davvero l’I/O, come gestire il pool di thread comune e come chiudere in sicurezza le risorse ( try-with-resources). In chiusura — uno sguardo rapido all’accesso posizionale tramite FileChannel per leggere/scrivere porzioni di file di grandi dimensioni.

Come velocizzare l'attraversamento di directory grandi e l'elaborazione di migliaia di file: usiamo Files.walk() e stream paralleli tramite parallel(), comprendiamo il ruolo di ForkJoinPool.commonPool() e impostiamo il grado di parallelismo. Vediamo quando conviene passare a ExecutorService, in cosa differiscono i task CPU-bound e IO-bound, scriviamo un esempio di conteggio delle righe in tutti i file ".java" e fissiamo le best practice.

Come velocizzare l'elaborazione di file da gigabyte: li suddividiamo in chunk (chunking), usiamo l'accesso posizionale tramite FileChannel e buffer memory-mapped MappedByteBuffer, parallelizziamo i calcoli con ExecutorService. Esamineremo i metodi chiave di I/O posizionale: position(...), read(...), write(...), i criteri per scegliere la dimensione del chunk, un esempio di conteggio parole in parallelo e gli errori tipici (confini dei chunk, risorse, numero di thread).

Analizziamo come organizzare una pipeline di elaborazione dei file secondo il pattern Producer–Consumer con uno scambio sicuro tramite BlockingQueue (ad esempio ArrayBlockingQueue), come funzionano le operazioni bloccanti put() e take(), perché serve il meccanismo di backpressure e come terminare correttamente i thread usando la “poison pill” (ad esempio "__END__", e non null). Avviamo i consumer tramite ExecutorService, aggiungiamo una visualizzazione della pipeline e analizziamo gli errori tipici.

Vediamo perché Java 9 ha introdotto il sistema modulare JPMS: cosa c’è di sbagliato nella “ classpath-party”, come i moduli introducono confini di visibilità a livello di contenitore, che cos’è module-info.java e come lavorare con le direttive module, exports, requires, opens, uses/ provides. Discuteremo vantaggi (incapsulamento, dipendenze esplicite, sicurezza, jlink), ambiti di applicazione (inclusi java.base, java.sql), utili sfumature ed errori tipici durante la migrazione ( exports dimenticato, requires mancante, nomi di moduli duplicati).