Lezioni

Pattern comportamentale «Osservatore»: ruoli Subject e Observer, iscrizione/disiscrizione tramite addObserver/ removeObserver, e invio delle notifiche con il metodo notifyObservers. Analizziamo il collegamento con il modello a eventi di Java: button. addActionListener( listener) ; → chiamata a actionPerformed(). Pratica con esempi (termometro e condizionatore, mini‑contatore e lambda), e anche perché java.util.Observable/ Observer sono deprecati e quali approcci moderni esistono.

In questa lezione analizziamo che cos’è il thread di gestione degli eventi dell’UI — EDT in Swing e il suo equivalente JavaFX Application Thread —, perché i componenti dell’interfaccia non sono thread-safe e per quale motivo la finestra “si blocca” durante compiti pesanti. Mostreremo le pratiche corrette: spostare i calcoli in background tramite new Thread(...), aggiornare l’interfaccia con le chiamate SwingUtilities.invokeLater e Platform.runLater, nonché utilizzare strumenti di livello più alto SwingWorker<T, V> e Task<V>/ Service<V> per avanzamento, annullamento e gestione degli errori.

Perché ai programmi servono thread e parallelismo: dall’interfaccia reattiva fino a sfruttare tutti i core del processore. Analizziamo la differenza tra processi e thread, il ruolo del thread principale main nella JVM, casi pratici (UI, server, elaborazione di file) e i rischi: race condition, deadlock, nonché gli strumenti base di sincronizzazione come synchronized. Mostreremo un semplice esempio con Thread e l’esecuzione di due task in parallelo.

In questa lezione analizziamo l'avvio dei thread in Java: conosciamo la classe Thread e l'interfaccia Runnable, impariamo a chiamare correttamente start() senza confonderlo con run(), usiamo classi anonime ed espressioni lambda, avviamo più thread e osserviamo il ciclo di vita ( NEW → RUNNABLE → TERMINATED). Parleremo dei metodi Thread.currentThread(), getName(), dell'attesa tramite join() e degli errori tipici come IllegalThreadStateException.

Analizziamo il ciclo di vita di un thread in Java: da Thread.State (

NEW

,

RUNNABLE

,

BLOCKED

,

WAITING

,

TIMED_WAITING

,

TERMINATED

) alle transizioni fra di essi. Impariamo a gestire i thread con Thread.sleep(...), join(), interrupt(), a diagnosticare lo stato tramite isAlive() e getState(), nonché a evitare i metodi obsoleti come stop()/ suspend()/ resume(). Infine — consigli pratici ed errori comuni.

Come passare in modo sicuro parametri ai thread attraverso il costruttore della classe che implementa Runnable, quando sono opportune le espressioni lambda e perché è meglio rendere i campi final. Analizziamo le priorità dei thread: metodi setPriority/ getPriority, costanti Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY e il loro effetto sullo scheduler. In più — denominazione dei thread tramite il costruttore, setName/ getName, esempio pratico ed errori tipici (Runnable condiviso, setter, speranze riposte nelle priorità).

In questa lezione analizziamo che cos’è una race condition: quando più thread accedono contemporaneamente a dati condivisi e il risultato dipende dall’ordine di pianificazione. Con l’esempio dell’incremento counter ++ mostriamo perché l’operazione non è atomica e come si perdono incrementi. Esaminiamo un caso pratico con un conto bancario, le conseguenze in produzione e gli approcci di protezione: synchronized, i tipi atomici di java.util.concurrent.atomic (ad esempio, AtomicInteger), nonché l’immutabilità. Concludiamo con la sezione «Errori tipici», dove si spiega perché i bug di Thread vengono raramente catturati dai test e perché «curarli» con Thread. sleep( 1) è inutile.

Questa lezione parla di che cos’è una risorsa condivisa nelle applicazioni multithread, perché si verificano le race condition e gli «aggiornamenti persi», e come proteggere i dati con synchronized. Vedremo le tecniche di base di sincronizzazione (metodi e blocchi), parleremo degli strumenti moderni di java.util.concurrent ( Lock, ReentrantLock, Semaphore e altri), vedremo esempi pratici con l’incremento di un contatore e gli errori tipici (non atomicità di i ++, oggetto di lock errato, miti su volatile).

Lezione pratica sulla multithreading: analizziamo come funziona la parola chiave synchronized (blocchi e metodi, monitor dell’oggetto e blocco a livello di classe ClassName.class), in cosa la visibilità delle modifiche tramite volatile differisce dall’atomicità delle operazioni, perché è comodo rendere volatile i flag boolean, mentre l’incremento count ++ richiede la sincronizzazione. Confronteremo quando scegliere synchronized e quando — volatile, e analizzeremo gli errori tipici.

Confronto pratico tra la sincronizzazione classica tramite synchronized e primitive più flessibili del pacchetto java.util.concurrent.locks: ReentrantLock e ReadWriteLock. Vedremo come gestire in modo esplicito i lock ( lock()/ unlock(), tryLock() con timeout), come scalare le letture con ReentrantReadWriteLock, che cos’è la fairness ( fair mode), dove ciascuno strumento è appropriato e quali errori si incontrano più spesso.

In questa lezione analizziamo i principali primitivi di sincronizzazione in Java: come proteggere le sezioni critiche con synchronized e la classe ReentrantLock (metodi lock()/ unlock(), costrutto try- finally), e come limitare il parallelismo tramite Semaphore (metodi acquire()/ release()). Confronteremo mutex e semaforo in una tabella, vedremo casi pratici (banca, server con limite di connessioni) ed errori tipici che portano a deadlock e perdite di prestazioni.

Analisi pratica degli errori frequenti del multithreading in Java: unlock()/ release() dimenticato con ReentrantLock e Semaphore (si risolve con try- finally), scelta del monitor sbagliato per synchronized, deadlock e ordine di acquisizione dei lock, sincronizzazione eccessiva, nonché limiti di applicabilità di volatile e sostituzione con AtomicInteger. Esempi, consigli e analogie comprensibili — in modo che il codice non si blocchi.