Lezioni

Come parallelizzare le attività e unire i risultati con CompletableFuture: unione di due risultati tramite thenCombine/ thenCombineAsync, attesa di un insieme di attività tramite allOf, reazione alla risposta più veloce tramite anyOf. Analizzeremo le firme, esempi pratici con supplyAsync, l’elaborazione non bloccante ( thenAccept, thenRun), nonché le sottigliezze degli errori e la loro gestione ( exceptionally, handle, whenComplete). Alla fine — una tabella compatta di confronto dei metodi.

Come intercettare e gestire in modo sicuro le eccezioni nelle catene CompletableFuture: analizziamo i ruoli di exceptionally (valore di fallback in caso di errore), handle (gestore universale di successo/errore) e whenComplete (azioni collaterali senza modificare il risultato). Discuteremo perché la chiamata diretta a get()/ join() incapsula le cause in ExecutionException/ CompletionException, come combinare le fasi ( thenApply, thenAccept) e quali errori tipici evitare.

Come «concatenare» correttamente i passi asincroni in CompletableFuture con thenCompose e quando basta thenApply; come e perché collegare un pool di thread proprio tramite ExecutorService (invece di ForkJoinPool.commonPool()); come proteggere le catene dall’«attesa infinita» con orTimeout e completeOnTimeout. Alla fine — un esempio pratico con un Executor personalizzato, thenCompose e un timeout, nonché errori tipici e le loro soluzioni.

In questa lezione analizziamo l'I/O asincrono (AIO) in Java NIO.2: in cosa differisce dall'I/O sincrono, come lavorare con AsynchronousFileChannel, avviare operazioni di lettura/scrittura tramite Future e CompletionHandler, e come incide la scelta del pool di thread ExecutorService. In pratica vedremo l'apertura del canale con open, i metodi read/ write, lo schema di interazione e gli errori comuni.

Come gestire in Java il completamento delle operazioni asincrone NIO2: «promesse» tramite Future e callback tramite CompletionHandler. Analizzeremo le firme di read/ write su AsynchronousFileChannel, l’ottenimento bloccante del risultato tramite get() e il polling con isDone(), nonché la gestione non bloccante in completed()/ failed(). Mostreremo esempi pratici di lettura/scrittura e un breve confronto degli approcci.

Esercitiamo l'I/O asincrono in Java: leggiamo grandi file di testo a blocchi in ByteBuffer tramite AsynchronousFileChannel, convertiamo correttamente i byte in caratteri con CharsetDecoder, scriviamo i dati in modo asincrono (tramite Future o CompletionHandler). Analizziamo il problema della «rottura» dei caratteri multibyte (ad esempio, "UTF-8"), il conteggio delle righe al volo, la scelta delle codifiche e gli errori tipici nel lavoro con buffer e canali.

Come intercettare e gestire correttamente gli errori nell’I/O asincrono di Java: callback CompletionHandler con i metodi completed/ failed, logging e notifiche. Analizziamo l’annullamento delle operazioni tramite Future e cancel( boolean), le conseguenze per get() e CancellationException, oltre a consigli pratici: try-with-resources, sincronizzazione con CountDownLatch/ CompletableFuture e rilascio delle risorse.

Analisi pratica delle insidie nell'I/O file asincrono in Java NIO: gestione corretta dei buffer ByteBuffer (proprietà position/ limit, chiamate flip(), clear(), compact()), race condition nelle operazioni parallele con AsynchronousFileChannel, chiusura delle risorse ( channel.close(), try-with-resources), gestione degli errori in CompletionHandler (metodo failed(...)), controllo del ciclo di vita delle operazioni tramite Future<Integer> e sincronizzazione con CountDownLatch, gestione corretta delle codifiche tramite CharsetDecoder, nonché scelta di un pool di thread appropriato ExecutorService.

Analizziamo in cosa differiscono i thread di piattaforma dai virtuali: come funziona il modello « Platform Thread → sistema operativo» e perché è pesante, cosa cambia con i thread virtuali ( Virtual Thread) sopra i carrier threads, e come questo offre scalabilità senza lo «spaghetti» reattivo. Vedremo la pratica con Thread.ofVirtual(), confronteremo il comportamento per attività I/O‑bound e CPU‑bound, toccheremo la compatibilità (chiamate bloccanti come InputStream.read, Socket.accept) e gli errori tipici (vecchie sincronizzazioni, aspettative di un «acceleramento magico»).

Pratica sui thread virtuali di Java 21: in cosa differiscono da quelli di piattaforma, come avviarli tramite Thread.startVirtualThread(...) e Thread.ofVirtual().start(...), quando è ancora opportuno new Thread(...) o Thread.ofPlatform(), e come eseguire in massa i task con Executors.newVirtualThreadPerTaskExecutor(). Esamineremo l’attesa del completamento con join(), la gestione degli errori con Future e ExecutionException, nonché gli errori tipici nell’uso dei Virtual Threads.

Confronto pratico tra i thread di piattaforma Thread e i thread virtuali di Java 21: come la JVM, grazie ai « carrier» (carrier threads), esegue centinaia di migliaia di task con memoria minima, dove i thread virtuali brillano (I/O-bound) e dove no (CPU-bound). Analizziamo le limitazioni ( synchronized, lock nativi), le buone pratiche ( Executors.newVirtualThreadPerTaskExecutor()), il monitoraggio con JVisualVM e Java Flight Recorder, nonché gli errori tipici durante la migrazione a Virtual Threads.

Vediamo come eseguire un singolo task in un singolo thread virtuale con Executors.newVirtualThreadPerTaskExecutor() (Java 21), in cosa questo differisce dai pool classici ( newFixedThreadPool, newCachedThreadPool), come terminare correttamente tramite shutdown() e awaitTermination(...), come ottenere i risultati dei task tramite Future e dove i thread virtuali danno il massimo vantaggio (I/O massivo, server web, test di carico). In chiusura — errori tipici e sfumature.