Multithreading CAPITOLO Introduzione

Transcript

1 CAPITOLO 1 Multithreading Obiettivi Comprendere il concetto di multithreading Capire come il multithreading sia in grado di migliorare le prestazioni dei programmi Creare, gestire ed eliminare i thread Conoscere il ciclo di vita di un thread Capire la sincronizzazione dei thread Comprendere il concetto di priorità e programmazione dei thread 1.1 Introduzione Il corpo umano esegue molte operazioni contenporaneamente o in parallelo. La respirazione, la circolazione sanguigna e la digestione, per esempio, avvengono contemporaneamente; anche i sensi (vista, tatto, olfatto, gusto e udito) possono essere tutti attivi nello stesso istante. Anche i computer possono svolgere più operazioni contemporaneamente. Per esempio, un PC è in grado di compilare un programma, trasmettere un file a una stampante e ricevere la posta elettronica contemporaneamente. Può sembrare strano che invece molti linguaggi di programmazione non permettano ai programmatori di specificare attività in parallelo. Questi linguaggi forniscono generalmente solo un gruppo di strutture di controllo che consentono ai programmatori di compiere un azione alla volta, ovvero l azione successiva può essere svolta dopo che quella precedente è stata completata. Il tipo di attività in parallelo che gli attuali computer eseguono è normalmente implementato sotto forma di primitive del sistema operativo accessibili soltanto ad esperti programmatori di sistema. Il linguaggio di programmazione Ada, sviluppato dal Dipartimento della Difesa degli Stati Uniti d America, metteva a disposizione varie primitive alle aziende che si occupavano della realizzazione dei sistemi di controllo e di comando della difesa. Tuttavia, Ada non venne adottato dalle università e dall industria. Class Library di.net Framework consente ai programmatori di utilizzare più primitive contemporaneamente per le loro applicazioni. Un programmatore può specificare che un applicazione contiene dei thread di esecuzione; ogni thread identifica una parte di programma che può essere eseguita parallelamente ad altri thread. Questa caratteristica, chiamata multithreading, è disponibile in tutti i linguaggi di programmazione.net, inclusi Visual Basic, C# e Visual C++.

2 2 CAPITOLO 1 Ingegneria del software 1.1 Il namespace System.Threading della Class Library di.net Framework supporta le funzionalità del multithreading. Questo agevola la diffusione del multithreading fra i programmatori e le società di software. In questo capitolo vedrete molte applicazioni di programmazione multithreading. Per esempio, quando i programmi scaricano file di grandi dimensioni, come i file audio o video dal World Wide Web, l utente non vuole aspettare che sia stato scaricato l intero file prima di poterne avviare la riproduzione. Per risolvere questo problema, è possibile utilizzare più thread: uno scarica il clip e un altro lo riproduce; in questo modo, le due attività (o task) possono essere svolte contemporaneamente. Per evitare che la riproduzione del file avvenga a singhiozzo, i thread vengono coordinati in modo che il thread addetto alla riproduzione non parta fino a che non siano state caricate sufficienti informazioni nella memoria. Un altro esempio di multithreading è il garbage collector (un meccanismo automatico di recupero della memoria detto spazzino ) di Visual Basic. Nei linguaggi C e C++ deve essere il programmatore a occuparsi di liberare la memoria allocata che non viene più utilizzata. Visual Basic, invece, dispone di un thread speciale (spazzino automatico) che libera dinamicamente la memoria allocata quando non è più richiesta dai programmi. Collaudo e messa a punto 1.1 Con i linguaggi C e C++ i programmatori devono scrivere esplicitamente delle istruzioni per liberare la memoria allocata dinamicamente. Se ciò non avviene (perché un programmatore dimentica di farlo, perché c è un errore di logica oppure perché un eccezione ha deviato altrove il flusso del programma), si genera un tipico fenomeno, chiamato perdita di memoria, che col passare del tempo può degenerare provocando l interruzione del programma. Grazie al garbage collector di Visual Basic, il rischio della perdita di memoria è notevolmente ridotto. Obiettivo efficienza 1.1 Una delle ragioni per le quali i linguaggi C e C++ hanno mantenuto la loro popolarità negli anni è che le tecniche di gestione della memoria erano più efficienti di quelle dei linguaggi che adottavano il garbage collector. Tuttavia, la gestione della memoria con Visual Basic di solito è più rapida rispetto ai linguaggi C e C++. Buona abitudine 1.1 Impostate il riferimento di un oggetto a Nothing quando il programma non ha più bisogno di questo oggetto. Ciò consente al garbage collector di liberare al più presto possibile la memoria allocata per l oggetto. Se il programma mantiene altri riferimenti di questo oggetto, il garbage collector non potrà operare. Scrivere programmi multithread non è semplice. Sebbene la mente umana sia in grado di svolgere più funzioni contemporaneamente, tuttavia le persone spesso trovano difficile saltare fra due treni di pensieri paralleli. Per capire perché sia difficile la programmazione multithread, fate questo esperimento: aprite tre libri alla prima pagina e tentate di leggerli in parallelo. Leggete alcune parole del primo libro, poi alcune parole del secondo libro e alcune parole del terzo libro; ritornate a leggere alcune parole del primo libro e così via. Questo esperimento dimostra come sia difficile passare da un libro all altro, leggendo poche parole

3 MULTITHREADING 3 alla volta, ricordandosi ogni volta l ultima parola letta e, soprattutto, come sia praticamente impossibile capire il contenuto dei tre libri. Obiettivo efficienza 1.2 Un problema che può verificarsi con le applicazioni con un solo thread è che, a volte, alcune attività molto lunghe devono essere completate prima che possano avere inizio altre attività. Nelle applicazioni multithread, invece, i vari thread possono condivedere uno o più processori, consentendo di svolgere più attività in parallelo. 1.2 Stati e ciclo di vita di un thread In qualsiasi momento, un thread si trova in uno dei vari stati illustrati nella Figura 1.1. Questo paragrafo descrive i vari stati e le transizioni da uno stato all altro. Due classi che sono essenziali per le applicazioni multithread sono Thread e Monitor (namespace System.Threading). Descriveremo anche i metodi di queste due classi che permettono le transizioni da uno stato all altro di un thread. Quando un programma crea un nuovo thread, questo inizia il suo ciclo di vita nello stato Unstarted. Il thread rimane in questo stato finché il programma non chiama il metodo Start della classe Thread; quando questo avviene, il thread entra nello stato Started o Ready. A questo punto, il thread che ha chiamato il metodo Start, il nuovo thread e altri thread del programma possono essere eseguiti in parallelo. Il thread Started che ha un livello di priorità più alto entra nello stato Running (inizia a essere eseguito) quando il sistema operativo gli assegna un processore (il Paragrafo 1.3 descrive i livelli di priorità dei thread). Quando un thread Started riceve un processore per Figura 1.1 Stati e ciclo di vita di un thread

4 4 CAPITOLO 1 la prima volta e diventa un thread Running, il thread esegue il suo delegato ThreadStart, che specifica le azioni che il thread svolgerà durante il suo ciclo di vita. Quando un programma crea un nuovo Thread, il programma specifica il delegato ThreadStart come argomento del costruttore Thread. Il delegato deve essere una procedura che non riceve argomenti. Un thread Running entra nello stato Stopped quando il suo delegato ThreadStart termina. Notate che un programma può forzare un thread nello stato Stopped chiamando il metodo Abort di Thread sull appropriato oggetto Thread. Il metodo Abort genera un eccezione ThreadAbortException che, di solito, provoca la fine del thread. Quando un thread si trova nello stato Stopped e non ci sono altri riferimenti al thread nel programma, il garbage collector può eliminare l oggetto dalla memoria. Un thread entra nello stato Blocked (bloccato) quando effettua una richiesta di input/ output. Il sistema operativo blocca l esecuzione del thread finché non viene completata l operazione di I/O richiesta dal thread. Una volta completata questa operazione, il thread ritorna nello stato Started e riprende la sua esecuzione. Un thread Blocked non può usare un processore, anche se questo fosse disponibile. Ci sono tre modi in cui un thread Running può entrare nello stato WaitSleepJoin. Se un thread incontra un codice che non può eseguire (di solito, una condizione che non è soddisfatta), il thread può chiamare il metodo Wait di Monitor per entrare nello stato WaitSleepJoin. Una volta in questo stato, il thread ritorna nello stato Started quando un altro thread chiama il metodo Pulse o PulseAll di Monitor. Il metodo Pulse sposta il successivo thread in attesa nello stato Started. Il metodo PulseAll sposta tutti i thread in attesa nello stato Started. In alternativa, un thread Running può chiamare il metodo Sleep di Thread per entrare nello stato WaitSleepJoin per il periodo di tempo (espresso in millisecondi) che è specificato come argomento di Sleep. Un thread Sleeping ritorna nello stato Started quando il suo tempo di sospensione scade. Come i thread Blocked, anche i thread Sleeping non possono usare un processore, anche se questo fosse disponibile. Qualsiasi thread che entra nello stato WaitSleepJoin chiamando il metodo Wait di Monitor o il metodo Sleep di Thread lascia lo stato WaitSleepJoin e ritorna nello stato Started se viene chiamato il metodo Interrupt di Thread da un altro thread del programma. Se un thread (detto thread dipendente) non può continuare l esecuzione finché non termina un altro thread, il thread dipendente chiama il metodo Join dell altro thread per unire (join) i due thread. Quando due thread sono uniti, il thread dipendente lascia lo stato WaitSleepJoin quando l altro thread finisce l esecuzione (entra nello stato Stopped). Se viene chiamato il metodo Suspend di un thread Running, il thread entra nello stato Suspended. Un thread Suspended ritorna nello stato Started quando un altro thread del programma chiama il metodo Resume del thread Suspended. 1.3 Priorità dei thread Ogni thread ha un livello di priorità che varia da un minimo (ThreadPriority.Lowest ThreadPriority.Lowest) a un massimo (ThreadPriority.Highest ThreadPriority.Highest). Questi due livelli provengono dall enumerazione ThreadPriority (namespace System.Threading), che contiene i valori Lowest, BelowNormal, Normal, AboveNormal e Highest. Per default, ogni nuovo thread ha priorità Normal. Lo scheduler di Visual Basic determina quando eseguire i singoli thread in base ai loro livelli di priorità. La piattaforma Windows supporta un concetto chiamato timeslicing, che consente ai thread di uguale priorità di condividere un processore. Senza il timeslicing, ogni thread

5 MULTITHREADING 5 all interno di un gruppo di thread dello stesso livello di priorità viene eseguito fino al completamento (a meno che il thread non lasci lo stato Running ed entri nello stato WaitSleepJoin, Suspended o Blocked) prima che gli altri thread possano essere eseguiti. Con il timeslicing, a ogni thread viene assegnato un periodo di tempo limitato, chiamato quantum o timeslice, durante il quale può essere eseguito. Allo scadere del quantum, anche se il thread non ha ancora finito l esecuzione, il processore passa al successivo thread di pari priorità (se ce n è uno disponibile). Il compito dello scheduler è mantenere sempre in esecuzione il thread con la priorità più elevata e, nel caso sia disponibile il timeslicing, assicurare che più thread di pari priorità vengano eseguiti un po alla volta. La Figura 1.2 mostra la coda dei thread di vari livelli di priorità. In questa figura, i thread A e B vengono eseguiti a turno per un quantum, finché entrambi non saranno completati. Questo significa che A riceve un quantum di tempo per essere eseguito, poi B riceve un quantum, poi A riceve un altro quantum, poi B e così via. Questo processo continua finché un thread non viene completato; a questo punto, il processore dedica tutto il suo tempo all altro thread (a meno che un altro thread di pari priorità non passi nello stato Started). Dopo i thread A e B, viene completato il thread C. Poi vengono eseguiti a turno i thread D, E e F, e così via, fino a completare tutti gli altri thread. Notate che nuovi thread di priorità elevata possono ritardare (anche per un tempo indefinito) l esecuzione dei thread di priorità più bassa. Questa condizione estrema di mancanza di risorse è detta starvation (fame). La priorità di un thread può essere modificata con la proprietà Priority, che accetta i valori dall enumerazione ThreadPriority. Se l argomento non è uno dei valori consentiti, si verifica un eccezione ArgumentException. Figura 1.2 Esecuzione di thread di vari livelli di priorità

6 6 CAPITOLO 1 Un thread viene eseguito fino a che muore (stato Stopped), passa allo stato Blocked per una richiesta di input/output (o per qualche altro motivo), chiama il metodo Sleep, chiama il metodo Wait o Join di Monitor, viene superato da un thread di priorità più alta o il suo quantum scade. Un thread con priorità più elevata del thread Running può passare allo stato Started (e da qui superare il thread Running) se un thread Sleeping si sveglia, se viene completata l operazione di I/O che teneva bloccato il thread, se viene chiamato il metodo Pulse o PulseAll su un oggetto per il quale il thread era in attesa o se viene completato un thread al quale era unito il thread di priorità più alta. Le Figure 1.3 e 1.4 applicano le tecniche di base del threading, quali la costruzione di un oggetto Thread e l utilizzo del metodo shared Sleep della classe Thread. Il modulo modthreadtester (Figura 1.4) crea tre thread, ciascuno dei quali ha la priorità di default Normal. Ogni thread visualizza un messaggio che indica cha sta andando a dormire (sleep) per un periodo di tempo casuale compreso fra 0 e 5000 millisecondi. Trascorso questo periodo, il thread visualizza un messaggio per indicare che si è svegliato, poi entra nello stato Stopped. Notate che il metodo Main (ovvero il thread di esecuzione principale) finisce prima che termini l applicazione. Il programma è formato da un modulo, modthreadtester (Figura 1.4), che crea i tre thread, e da una classe, CMessagePrinter (Figura 1.3), che definisce un metodo Print che contiene le azioni che dovranno essere svolte da ciascun thread. 1 File: MessagePrinter.vb 2 un metodo di controllo dei thread che visualizza 3 dei messaggi per indicare lo stato dei thread 4 5 Imports System.Threading 6 7 Public Class CMessagePrinter 8 9 Private sleeptime As Integer 10 Private Shared randomobject As New Random() costruttore per inizializzare un oggetto CMessagePrinter 13 Public Sub New() imposta la durata casuale di sleeptime fra 0 e 5 secondi 16 sleeptime = randomobject.next(5001) 17 End Sub New il metodo Print controlla il thread dei messaggi 20 Public Sub Print() ottiene un riferimento al thread in esecuzione 23 Dim current As Thread = Thread.CurrentThread pone il thread nello stato Sleeping per una certa durata 26 Console.WriteLine(current.Name & going to sleep for & _ 27 sleeptime) Thread.Sleep(sleepTime) visualizza il nome del thread

7 MULTITHREADING 7 32 Console.WriteLine(current.Name & done sleeping ) 33 End Sub Print End Class CmessagePrinter Figura 1.3 Il metodo Print descrive le azioni svolte dai thread Gli oggetti della classe CMessagePrinter (Figura 1.3) controllano il ciclo di vita di ciascuno dei tre thread creati dal metodo Main di modthreadtester. La classe CMessagePrinter è formata dalla variabile di istanza sleeptime (riga 9), dalla variabile shared randomobject (riga 10), da un costruttore (righe 13-17) e da un metodo Print (righe 20-33). La variabile sleeptime contiene un valore casuale di tipo Integer che è scelto quando viene chiamato il costruttore di un nuovo oggetto CMessagePrinter. Ogni thread controllato da un oggetto CMessagePrinter resta nello stato Sleeping per il periodo di tempo specificato dal valore sleeptime del corrispondente oggetto CMessagePrinter. Il costruttore CMessagePrinter (righe 13-17) inizializza sleeptime con un valore intero casuale compreso fra 0 e 5000 (l estremo 5001 è escluso). Il metodo Print (righe 20-33) inizia ottenendo un riferimento al thread che è in corso di esecuzione (riga 23) attraverso la proprietà shared CurrentThread della classe Thread. Il thread correntemente in esecuzione è quello che chiama il metodo Print. Successivamente, le righe visualizzano un messaggio che contiene il nome del thread corrente e la durata in millisecondi dello stato Sleeping del thread. Notate che la riga 26 usa il thread corrente tramite la proprietà Name, che viene impostata nel metodo Main (Figura 1.4, righe 8-35) quando viene creato il thread. La riga 29 chiama il metodo shared Sleep per porre il thread nello stato WaitSleepJoin. A questo punto, il thread perde il processore e il sistema consente l esecuzione di un altro thread. Quando il thread si sveglia, ritorna nello stato Started finché non gli viene assegnato un processore. Quando l oggetto CMessagePrinter entra di nuovo nello stato Running, la riga 32 visualizza il nome del thread in un messaggio che indica che il thread ha finito di dormire; il metodo Print si conclude. Il modulo Main di modthreadtester (Figura 1.4, righe 8-35) crea tre oggetti della classe CMessagePrinter (righe 11-13). Le righe creano e inizializzano tre oggetti Thread che corrispondono agli oggetti CMessagePrinter creati. Le righe impostano la proprietà Name di ciascun thread. Notate che il costruttore di ogni thread riceve come argomento un delegato ThreadStart. Ricordiamo che un delegato ThreadStart specifica le azioni che un thread svolge durante il suo ciclo di vita. La riga 17 specifica che il delegato thread1 sarà il metodo Print dell oggetto cui fa riferimento printer1. Quando thread1 entra nello stato Running per la prima volta, thread1 chiama il metodo Print di printer1 per svolgere i compiti specificati nel corpo del metodo Print. Poi, thread1 visualizza il nome del thread e la durata del periodo di Sleeping; trascorso questo periodo, il thread visualizza un messaggio per indicare che si è svegliato. Qui termina il metodo Print. Un thread completa il suo compito quando termina il metodo specificato da un delegato ThreadStart di Thread, ponendo il thread nello stato Stopped. Quando thread2 e thread3 entrano per la prima volta nello stato Running, chiamano i metodi Print, rispettivamente, di printer2 e printer3. I thread thread2 e thread3 svolgono gli stessi compiti di thread1 eseguendo i metodi Print degli oggetti cui fanno riferimento printer2 e printer3 (ciascuno con un valore di sleeptime scelto a caso). Le righe chiamano il metodo Start dei vari thread per porli nello stato Started (questo processo è detto anche lancio del thread). La riga 34 visualizza un messaggio che

8 8 CAPITOLO 1 indica che i thread sono stati avviati; l esecuzione del thread Main termina. Il programma non termina, invece, perché contiene ancora thread vivi (quelli che si trovano nello stato Started e non hanno ancora raggiunto lo stato Stopped). Il programma termina quando muore l ultimo thread. Quando il sistema assegna un processore a un thread, questo entra nello stato Running e chiama il metodo specificato dal delegato ThreadStart. In questo programma, ogni thread chiama il metodo Print dell oggetto CMessagePrinter appropriato per svolgere i compiti precedentemente descritti. Notate che l output della Figura 1.4 visualizza il nome e la durata dello stato Sleeping di ciascun thread. Il thread con la durata di Sleeping più breve è quello che di solito si sveglia per primo; poi indica che ha dormito e la sua esecuzione termina. Il Paragrafo 1.7 descrive i fattori che possono impedire al thread con durata di Sleeping più breve di svegliarsi per primo. Collaudo e messa a punto 1.2 I nomi assegnati ai thread agevolano il debugging di un programma multithread. Il debugger di Visual Studio.NET ha una finestra Threads che visualizza il nome di ogni thread e consente ai programmatori di osservare l esecuzione di qualsiasi thread del programma. 1 File: ThreadTester.vb 2 genera tre thread 3 4 Imports System.Threading 5 6 Module modthreadtester 7 8 Sub Main() 9 10 crea le istanze di CMessagePrinter 11 Dim printer1 As New CMessagePrinter() 12 Dim printer2 As New CMessagePrinter() 13 Dim printer3 As New CMessagePrinter() crea i thread; usa il metodo Print 16 di CMessagePrinter come argomento di ThreadStart 17 Dim thread1 As New Thread(AddressOf printer1.print) 18 Dim thread2 As New Thread(AddressOf printer2.print) 19 Dim thread3 As New Thread(AddressOf printer3.print) assegna un nome a ogni thread 22 thread1.name = thread1 23 thread2.name = thread2 24 thread3.name = thread Console.WriteLine( Starting threads ) chiama il metodo Start di ciascun thread per 29 metterlo nello stato Started 30 thread1.start() 31 thread2.start() 32 thread3.start() 33

9 MULTITHREADING 9 34 Console.WriteLine( Threads started & vbcrlf) 35 End Sub Main End Module modthreadtester Starting threads Threads started thread1 going to sleep for 1977 thread2 going to sleep for 4513 thread3 going to sleep for 1261 thread3 done sleeping thread1 done sleeping thread2 done sleeping Starting threads Threads started thread1 going to sleep for 1466 thread2 going to sleep for 4245 thread3 going to sleep for 1929 thread1 done sleeping thread3 done sleeping thread2 done sleeping Figura 1.4 Il modulo modthreadtester crea tre thread 1.4 Sincronizzazione dei thread Può capitare che più thread in esecuzione manipolino i dati condivisi (shared). Se i thread che hanno accesso ai dati condivisi si limitano a leggere questi dati, non c è bisogno di impedire l accesso ai dati a più thread contemporaneamente. Se, invece, più thread condividono e possono modificare gli stessi dati, allora si corre il rischio di generare risultati indeterminati. Se un thread sta aggiornando i dati e un altro thread tenta di aggiornare gli stessi dati, i dati risultanti rifletteranno l aggiornamento più recente. Se i dati sono raccolti in un array o in un altra struttura di cui i thread possono aggiornare contemporaneamente parti distinte, è possibile che una parte dei dati rifletta l aggiornamento di un thread, mentre un altra parte rifletta l aggiornamento di un thread differente. Se si verifica questo, è difficile per il programma stabilire se i dati siano stati aggiornati in modo appropriato. I programmatori possono risolvere questo problema assegnando a un determinato thread l accesso esclusivo ai dati durante l operazione di aggiornamento. In altri termini, mentre un thread sta manipolando i dati, tutti gli altri thread che desiderano accedere ai dati devono attendere che il primo completi la sua operazione. Dopo che il thread con accesso esclusivo ai dati ha completato la sua operazione, il programma può consentire al primo thread che è rimasto in attesa di accedere ai dati. In questo modo, ogni thread che accede ai dati esclude automaticamente tutti gli altri thread. Questo meccanismo si chiama mutua esclusione o sincronizzazione dei thread. Visual Basic utilizza i monitor di.net Framework per eseguire la sincronizzazione dei thread. La classe Monitor possiede i metodi per bloccare gli oggetti, consentendo così di implementare l accesso sincronizzato ai dati condivisi. Se un oggetto è bloccato (locked), un

10 10 CAPITOLO 1 solo thread alla volta può accedere a questo oggetto. Quando un thread tenta di acquisire il controllo esclusivo di un oggetto, chiama il metodo Enter di Monitor per bloccare l oggetto. Ogni oggetto ha un SyncBlock che mantiene lo stato di blocco dell oggetto. I metodi della classe Monitor usano i dati di SyncBlock per determinare lo stato di blocco di un oggetto. Dopo avere bloccato un oggetto, un thread può manipolare i dati dell oggetto. Mentre l oggetto è bloccato, tutti gli altri thread sono bloccati (ovvero entrano nello stato Blocked) e non possono porre un blocco all oggetto. Quando il thread che ha bloccato l oggetto condiviso non ha più bisogno del blocco, chiama il metodo Exit di Monitor per togliere il blocco; questa operazione aggiorna il valore SyncBlock dell oggetto condiviso per indicare che il blocco dell oggetto è di nuovo disponibile. A questo punto, un thread nello stato Blocked, che in precedenza non poteva bloccare l oggetto condiviso, adesso può farlo e iniziare a manipolare l oggetto. Se tutti i thread con accesso a un oggetto devono porre il blocco sull oggetto prima di manipolarlo, ciò potrà essere fatto da un solo thread alla volta. Questo aiuta a garantire l integrità dei dati. Errore tipico 1.1 Verificate che il codice che aggiorna un oggetto condiviso blocchi l oggetto prima di farlo; altrimenti, un thread che chiama un metodo che non blocca l oggetto può rendere instabile l oggetto, anche quando un altro thread ha posto un blocco sull oggetto. Errore tipico 1.2 Un deadlock si verifica quando l esecuzione di un thread (per esempio, thread1) non può proseguire, perché è in attesa di un altro thread (thread2); analogamente, thread2 non può proseguire perché, a sua volta, è in attesa di thread1. Poiché i due thread sono in attesa l uno dell altro, le loro azioni non potranno mai essere svolte. Visual Basic dispone di altri strumenti per manipolare il blocco di un oggetto: la parola chiave SyncLock. Esaminate le seguenti istruzioni: SyncLock ( riferimentooggetto ) qui va scritto il codice che richiede la sincronizzazione End SyncLock La struttura SyncLock End SyncLock pone un blocco sull oggetto identificato dal riferimentooggetto fra parentesi. Il termine riferimentooggetto è lo stesso riferimento che normalmente verrebbe passato ai metodi Enter, Exit, Pulse e PulseAll di Monitor. Quando una struttura SyncLock termina, Visual Basic libera il blocco posto sull oggetto identificato da riferimentooggetto. Per maggiori informazioni su SyncLock, consultate il Paragrafo 1.7. Se un thread determina che non può svolgere il suo compito sull oggetto bloccato, può chiamare il metodo Wait di Monitor, passando come argomento l oggetto per il quale il thread resterà in attesa finché potrà svolgere il suo compito. Chiamando il metodo Wait da un thread si libera il blocco che il thread ha sull oggetto che il metodo Wait riceve come argomento. Il thread che chiama il metodo Wait passa nello stato WaitSleepJoin per l oggetto. Un thread nello stato WaitSleepJoin per un oggetto lascia questo stato quando un altro thread chiama il metodo Pulse o PulseAll di Monitor con tale oggetto come argomento. Il metodo Pulse passa il primo thread in attesa dallo stato WaitSleepJoin allo stato Started. Il metodo PulseAll passa tutti i thread dallo stato WaitSleepJoin allo stato Started. La transizione allo stato Started consente al thread (o ai thread) di prepararsi a continuare l esecuzione.

11 MULTITHREADING 11 C è una differenza fra i thread in attesa di porre il blocco su un oggetto e i thread che sono in attesa nello stato WaitSleepJoin per un oggetto. I thread in attesa nello stato WaitSleepJoin chiamano il metodo Wait di Monitor con l oggetto come argomento. I thread che sono in attesa di porre il blocco, invece, passano nello stato Blocked e restano qui finché non sarà liberato il blocco dell oggetto; successivamente, uno dei thread Blocked potrà applicare il blocco all oggetto. I metodi Enter, Exit, Wait, Pulse e PulseAll di Monitor ricevono come argomento un riferimento a un oggetto (di solito, la parola chiave Me). Errore tipico 1.3 Un thread nello stato WaitSleepJoin non può ritornare nello stato Started per riprendere l esecuzione finché un altro thread non chiamerà il metodo Pulse o PulseAll di Monitor con l oggetto appropriato come argomento. Se questo non accade, il thread resterà in attesa per sempre, generando un deadlock. Collaudo e messa a punto 1.3 Quando più thread manipolano un oggetto condiviso tramite i monitor, il programmatore dovrà verificare che, se un thread chiama il metodo Wait di Monitor per passare nello stato WaitSleepJoin, un altro thread dovrà chiamare il metodo Pulse di Monitor per riportare il thread nello stato Started. Se più thread sono in attesa per lo stesso oggetto condiviso, un altro thread può chiamare il metodo PulseAll di Monitor per garantire che tutti i thread abbiano un altra opportunità di svolgere il loro compito. Obiettivo efficienza 1.3 La sincronizzazione dei thread nei programmi multithread può rallentare la loro esecuzione, a causa delle operazioni extra dei monitor e delle frequenti transizioni dei thread fra gli stati Running, WaitSleepJoin e Started, ma ne garantisce la correttezza. 1.5 Tread non sincronizzati In una relazione di tipo produttore/consumatore, un thread produttore chiama un metodo di produzione per generare i dati e depositarli in un area condivisa della memoria, chiamata buffer; successivamente, un thread consumatore chiama un metodo di consumazione per leggere questi dati. Se il produttore che è in attesa di inserire i nuovi dati nel buffer si accorge che il consumatore non ha letto i precedenti dati del buffer, il thread produttore deve chiamare il metodo Wait; altrimenti, il consumatore non vedrà mai i dati precedenti e l applicazione perderà questi dati. Quando il thread consumatore legge i dati, deve chiamare il metodo Pulse per consentire di procedere al produttore in attesa. Quando un thread consumatore trova il buffer vuoto o si accorge di avere già letto i dati, deve chiamare il metodo Wait; altrimenti, il consumatore potrebbe leggere la spazzatura nel buffer o potrebbe elaborare i dati precedenti più di una volta. In entrambi i casi, si verifica un errore di logica nell applicazione. Quando un produttore inserisce nuovi dati nel buffer, deve chiamare il metodo Pulse per consentire al thread consumatore di procedere. Esaminiamo come possano verificarsi gli errori di logica se non sincronizziamo l accesso di più thread che manipolano i dati condivisi. Per esempio, supponiamo di avere una relazione produttore/consumatore nella quale un thread produttore scrive una sequenza di numeri (1, 2, 3, 4) in un buffer condiviso (una locazione di memoria condivisa fra più thread). Il thread consumatore legge questi dati dal buffer e li visualizza. In questo esempio, visualizzeremo ciò

12 12 CAPITOLO 1 che il produttore scrive (produce) e ciò che il consumatore legge (consuma). La Figura 1.8 mostra un produttore e un consumatore che accedono a una singola cella condivisa di memoria (la variabile mbuffer di tipo Integer), senza alcuna sincronizzazione. I thread cosumatore e produttore possono accedere a questa singola cella: il produttore per scrivere, il consumatore per leggere. Vorremmo che ogni valore che il produttore scrive nella cella sia letto una sola volta dal consumatore. Poiché i thread non sono sincronizzati, i dati potrebbero perdersi se il produttore inserisse nuovi dati in memoria prima che il consumatore possa consumare quelli precedenti; inoltre, i dati potrebbero essere erroneamente duplicati, se il consumatore leggesse una seconda volta i dati prima che il produttore possa generare quelli nuovi. Per mostrare tutte queste possibilità, il thread consumatore di questo esempio calcola il totale di tutti i valori che legge. Il thread produttore produce valori da 1 a 4; se il consumatore è in grado di leggere una sola volta ogni valore prodotto, il totale dovrebbe essere 10; tuttavia, se provate a eseguire più volte questo programma, vedrete che è raro ottenere questo totale. I thread produttore e consumatore dell esempio dormono per periodi di tempo casuali (massimo 3 secondi) durante lo svolgimento dei loro compiti. Quindi non sappiamo con esattezza quando il thread produttore scriverà un nuovo valore né quando il thread consumatore leggerà un valore. Il programma è formato dal modulo modsharedcell (Figura 1.8) e da tre classi: CHoldIntegerUnsynchronized (Figura 1.5), CProducer (Figura 1.6) e CConsumer (Figura 1.7). La classe CHoldIntegerUnsynchronized (Figura 1.5) è formata dalla variabile di istanza mbuffer (riga 9) e dalla proprietà Buffer (righe 12-28), che include i metodi di accesso Get e Set. Questi metodi non sincronizzano l accesso alla variabile di istanza mbuffer. Notate che ciascuno di questi metodi usa la proprietà condivisa CurrentThread della classe Thread per ottenere un riferimento al thread correntemente in esecuzione e la proprietà Name di questo thread per ottenere il nome del thread. 1 File: HoldIntegerUnsynchronized.vb 2 Definizione di un buffer condiviso senza sincronizzazione 3 4 Imports System.Threading 5 6 Public Class CHoldIntegerUnsynchronized 7 8 buffer condiviso dai thread produttore e consumatore 9 Private mbuffer As Integer = la proprietà Buffer 12 Property Buffer() As Integer Get 15 Console.WriteLine(Thread.CurrentThread.Name & _ 16 reads & mbuffer) Return mbuffer 19 End Get Set(ByVal Value As Integer) 22 Console.WriteLine(Thread.CurrentThread.Name & _ 23 writes & Value)

13 MULTITHREADING mbuffer = Value 26 End Set End Property Buffer End Class CHoldIntegerUnsynchronized Figura 1.5 Il buffer condiviso senza meccanismi di sincronizzazione La classe CProducer (Figura 1.6) è formata dalle variabili di istanza sharedlocation (riga 8) e randomsleeptime (riga 9), da un costruttore (righe 12-17) per inizializzare le variabili di istanza e da un metodo Produce (righe 20-33). Il costruttore inizializza la variabile di istanza sharedlocation in modo che faccia riferimento all oggetto CHoldIntegerUnsynchronized ricevuto dal metodo Main. Il thread produttore in questo programma esegue i compiti specificati nel metodo Produce della classe CProducer. Il metodo Produce contiene una struttura For (righe 25-28) che esegue quattro iterazioni di un ciclo. In ogni iterazione, il metodo Sleep di Thread pone il thread produttore nello stato WaitSleepJoin per un intervallo di tempo casuale compreso fra 0 e 3 secondi (riga 26). Quando il thread si sveglia, la riga 27 assegna il valore della variabile di controllo count alla proprietà Buffer dell oggetto CHoldIntegerUnsynchronized, che fa sì che il metodo Set di CHoldIntegerUnsynchronized modifichi la variabile di istanza mbuffer dell oggetto CHoldIntegerUnsynchronized. Alla fine del ciclo, le righe visualizzano una riga di testo nella finestra di comando per indicare che il thread ha finito di produrre dati. Il metodo Produce termina ponendo il thread produttore nello stato Stopped. 1 File: Producer.vb 2 Genera numeri interi da 1 a 4 e li pone 3 in un buffer non sincronizzato 4 5 Imports System.Threading 6 7 Public Class CProducer 8 Private sharedlocation As CHoldIntegerUnsynchronized 9 Private randomsleeptime As Random costruttore 12 Public Sub New(ByVal sharedobject As _ 13 CHoldIntegerUnsynchronized, ByVal randomobject As Random) sharedlocation = sharedobject 16 randomsleeptime = randomobject 17 End Sub New registra i valori 1-4 nell oggetto sharedlocation 20 Public Sub Produce() 21 Dim count As Integer dorme per un periodo di tempo casuale fino a 3 secondi 24 imposta la proprietà Buffer di sharedlocation 25 For count = 1 To 4 26 Thread.Sleep(randomSleepTime.Next(3000)) Figura 1.6 Il produttore pone i valori interi in un buffer non sincronizzato (continua)

14 14 CAPITOLO 1 27 sharedlocation.buffer = count 28 Next Console.WriteLine(Thread.CurrentThread.Name & _ 31 done producing. & vbcrlf & Terminating & _ 32 Thread.CurrentThread.Name &. ) 33 End Sub Produce End Class CProducer Figura 1.6 Il produttore pone i valori interi in un buffer non sincronizzato La classe CConsumer (Figura 1.7) è formata dalle variabili di istanza sharedlocation (riga 7) e randomsleeptime (line 8), da un costruttore (righe 11-16) per inizializzare le variabili di istanza e da un metodo Consume (righe 19-32). Il costruttore inizializza sharedlocation in modo che faccia riferimento all oggetto CHoldIntegerUnsynchronized ricevuto dal metodo Main come argomento sharedobject. Il thread consumatore in questo programma svolge i compiti specificati nel metodo Consume della classe CConsumer. Il metodo contiene una struttura For (righe 24-27) che esegue quattro iterazioni di un ciclo. In ogni iterazione, il metodo Sleep di Thread pone il thread consumatore nello stato WaitSleepJoin per un intervallo di tempo casuale compreso fra 0 e 3 secondi (riga 25). La riga 26 acquisisce il valore della proprietà Buffer dell oggetto CHoldIntegerUnsynchronized e aggiunge il valore alla variabile sum. Alla fine del ciclo, le righe visualizzano una riga di testo nella finestra di comando per indicare la somma di tutti i valori letti. Il metodo Consume termina ponendo il thread consumatore nello stato Stopped. 1 File: Consumer.vb 2 Legge 4 valori interi nel buffer non sincronizzato 3 4 Imports System.Threading 5 6 Public Class CConsumer 7 Private sharedlocation As CHoldIntegerUnsynchronized 8 Private randomsleeptime As Random 9 10 costruttore 11 Public Sub New(ByVal sharedobject As _ 12 CHoldIntegerUnsynchronized, ByVal randomobject As Random) sharedlocation = sharedobject 15 randomsleeptime = randomobject 16 End Sub New registra i valori 1-4 nell oggetto sharedlocation 19 Public Sub Consume() 20 Dim count, sum As Integer dorme per un periodo di tempo casuale (max 3 sec); aggiunge 23 a sum il valore della proprietà Buffer di sharedlocation 24 For count = 1 To 4 25 Thread.Sleep(randomSleepTime.Next(3000)) 26 sum += sharedlocation.buffer

15 MULTITHREADING Next Console.WriteLine(Thread.CurrentThread.Name & _ 30 read values totaling: & sum &. & vbcrlf & _ 31 Terminating & Thread.CurrentThread.Name &. ) 32 End Sub Consume End Class CConsumer Figura 1.7 Il thread consumatore legge i valori nel buffer non sincronizzato Notate che in questo esempio utilizziamo il metodo Sleep per mettere in risalto il fatto che, nelle applicazioni multithreaded, non è chiaro quando un thread svolgerà il suo compito e quanto tempo occorrerà per svolgerlo. Di norma, è il sistema operativo del computer che gestisce questi problemi. Nel programma in esame, i compiti del nostro thread sono semplici: il produttore deve eseguire un ciclo quattro volte con un istruzione di assegnazione; il consumatore deve eseguire un ciclo quattro volte e aggiungere un valore alla variabile sum. Se omettiamo la chiamata del metodo Sleep e il produttore viene eseguito per primo, il suo compito sarà completato prima che il consumatore possa avere una possibilità di essere eseguito. Nella stessa situazione, se il consumatore viene eseguito per primo, legge quattro volte il valore 1 e termina prima che il produtttore possa generare un valore. Il metodo Main del modulo modsharedcell (Figura 14.8) instanzia un oggetto condiviso CHoldIntegerUnsynchronized (riga 14) e un oggetto Random (riga 17) per generare valori casuali del periodo di Sleeping; poi passa questi oggetti come argomenti ai costruttori degli oggetti delle classi CProducer (producer producer, riga 20) e CConsumer (consumer consumer, riga 21). L oggetto CHoldIntegerUnsynchronized contiene i dati che saranno condivisi fra i thread produttore e consumatore. La riga 25 crea producerthread. Il delegato ThreadStart per producerthread specifica che il thread eseguirà il metodo Produce dell oggetto producer. La riga 26 crea consumerthread. Il delegato ThreadStart per consumerthread specifica che il thread eseguirà il metodo Consume dell oggetto consumer. Le righe chiamano i thread producerthread e consumerthread. Infine, le righe pongono i due thread nello stato Started chiamando il metodo Start; a questo punto termina il thread Main. Il nostro obiettivo è ottenere che ogni valore prodotto dall oggetto CProducer sia consumato una sola volta dall oggetto CConsumer. Tuttavia, se analizziamo il primo output della Figura 1.8, notiamo che il consumatore legge un valore ( 1 1) prima che il produttore ponga un valore nel buffer condiviso; inoltre il valore 1 è letto tre volte. Il consumatore termina l esecuzione prima che il produttore abbia l opportunità di generare i valori 2, 3 e 4. Ne consegue che questi tre valori vengono perduti. Nel secondo output, notiamo che manca il valore 1, perché i valori 1 e 2 vengono generati prima che il thread consumatore possa leggere il valore 1; inoltre il valore 4 viene letto (consumato) due volte. L ultimo output dimostra che è possibile, con un po di fortuna, ottenere il risultato appropriato: ogni valore generato dal thread produttore viene letto una sola volta dal thread consumatore. Questo esempio dimostra chiaramente che l accesso ai dati condivisi da più thread deve essere attentamente controllato, altrimenti un programma potrebbe produrre risultati sbagliati. Per risolvere i problemi del precedente esempio (perdita e duplicazione dei dati), sincronizziamo l accesso dei thread produttore e consumatore (Figura 1.9) ai dati condivisi utilizzando i metodi Enter, Wait, Pulse e Exit di Monitor. Quando un thread usa l accesso sincronizzato a un oggetto condiviso, l oggetto viene bloccato e nessun altro thread può porre il blocco (lock) a quest oggetto, finché il primo thread non libererà l oggetto.

16 16 CAPITOLO 1 1 File: SharedCell.vb 2 Crea i thread produttore e consumatore 3 che interagiscono fra di loro attraverso 4 l oggetto comune CHoldIntegerUnsynchronized 5 6 Imports System.Threading 7 8 Module modsharedcell 9 10 crea il produttore e il consumatore 11 Sub Main() crea l oggetto condiviso dai thread 14 Dim holdinteger As New CHoldIntegerUnsynchronized() oggetto casuale utilizzato dai thread 17 Dim randomobject As New Random() crea gli oggetti CProducer e CConsumer 20 Dim producer As New CProducer(holdInteger, randomobject) 21 Dim consumer As New CConsumer(holdInteger, randomobject) crea i thread per il produttore e il consumatore 24 imposta i delegati per i thread 25 Dim producerthread As New Thread(AddressOf producer.produce) 26 Dim consumerthread As New Thread(AddressOf consumer.consume) assegna i nomi ai thread 29 producerthread.name = Producer 30 consumerthread.name = Consumer inizia i thread 33 producerthread.start() 34 consumerthread.start() 35 End Sub Main End Module modsharedcell Consumer reads 1 Producer writes 1 Consumer reads 1 Consumer reads 1 Consumer reads 1 Consumer read values totaling: 2. Terminating Consumer. Producer writes 2 Producer writes 3 Producer writes 4 Producer done producing. Terminating Producer.

17 MULTITHREADING 17 Producer writes 1 Producer writes 2 Consumer reads 2 Producer writes 3 Consumer reads 3 Producer writes 4 Producer done producing. Terminating Producer. Consumer reads 4 Consumer reads 4 Consumer read values totaling: 13. Terminating Consumer. Producer writes 1 Consumer reads 1 Producer writes 2 Consumer reads 2 Producer writes 3 Consumer reads 3 Producer writes 4 Producer done producing. Terminating Producer. Consumer reads 4 Consumer read values totaling: 10. Terminating Consumer. Figura 1.8 I thread produttore e consumatore accedono a un oggetto condiviso senza sincronizzazione 1.6 Thread sincronizzati La Figura 1.12 mostra un produttore e un consumatore che accedono in modo sincronizzato a una cella di memoria condivisa. Il consumatore legge un valore soltanto dopo che il produttore lo ha generato; inoltre, il produttore genera un nuovo valore soltanto dopo che il consumatore ha letto il valore precedentemente generato. Le classi CProducer (Figura 1.10), CConsumer (Figura 1.11) e il modulo modsharedcell (Figura 1.12) sono identici, rispettivamente, a quelli delle Figure 1.6, 1.7 e 1.8, tranne il fatto che usano la nuova classe CHoldIntegerSynchronized (Figura 1.9). Notate che questo esempio applica la sincronizzazione con i metodi Enter e Exit della classe Monitor. Nel prossimo esempio, illustreremo gli stessi concetti utilizzando SyncLock. 1 File: HoldIntegerSynchronized.vb 2 Sincronizza l accesso a valori di tipo Integer 3 4 Imports System.Threading 5 6 Public Class CHoldIntegerSynchronized 7 Figura 1.9 Il buffer condiviso sincronizzato (continua)

18 18 CAPITOLO 1 8 buffer condiviso dai thread produttore e consumatore 9 Private mbuffer As Integer = occupiedbuffercount conta i buffer occupati 12 Private occupiedbuffercount As Integer Public Property Buffer() As Integer Get ottiene il blocco su questo oggetto 19 Monitor.Enter(Me) se non ci sono dati da leggere, il thread 22 viene posto nello stato WaitSleepJoin 23 If occupiedbuffercount = 0 Then 24 Console.WriteLine(Thread.CurrentThread.Name & _ 25 tries to read. ) DisplayState( Buffer empty. & _ 28 Thread.CurrentThread.Name & waits. ) Monitor.Wait(Me) 31 End If indica che il produttore può registrare un altro valore 34 perché il consumatore ha appena letto il valore del buffer 35 occupiedbuffercount = DisplayState(Thread.CurrentThread.Name & reads & _ 38 mbuffer) indica all eventuale thread in attesa di 41 passare nello stato Started 42 Monitor.Pulse(Me) Crea una copia del buffer prima di liberare il blocco 45 E possibile che al produttore possa essere assegnato 46 il processore subito dopo che il monitor 47 viene liberato e prima dell istruzione Return 48 In questo caso, il produttore dovrebbe assegnare 49 un nuovo valore al buffer prima che l istruzione 50 Return restituisca il valore al consumatore. 51 Il consumatore riceverà il nuovo valore. 52 Creando una copia del buffer e restituendo 53 la copia, è più facile garantire che il 54 consumatore riceva il valore appropriato 55 Dim buffercopy As Integer = mbuffer libera il blocco dell oggetto

19 MULTITHREADING Monitor.Exit(Me) Return buffercopy 61 End Get Set(ByVal Value As Integer) acquisisce il blocco per l oggetto 66 Monitor.Enter(Me) se non ci sono locazioni vuote, 69 il thread passa nello stato WaitSleepJoin 70 If occupiedbuffercount = 1 Then 71 Console.WriteLine(Thread.CurrentThread.Name & _ 72 tries to write. ) DisplayState( Buffer full. & _ 75 Thread.CurrentThread.Name & waits. ) Monitor.Wait(Me) 78 End If imposta il nuovo valore del buffer 81 mbuffer = Value indica al produttore che non può registrare un altro 84 valore, finché il consumatore non legge il buffer 85 occupiedbuffercount += DisplayState(Thread.CurrentThread.Name & writes & _ 88 mbuffer) indica all eventuale thread in attesa di 91 passare nello stato Started 92 Monitor.Pulse(Me) libera il blocco dell oggetto 95 Monitor.Exit(Me) 96 End Set End Property Buffer Public Sub DisplayState(ByVal operation As String) 101 Console.WriteLine( {0, 35}{1, 9}{2} & vbcrlf, _ 102 operation, mbuffer, occupiedbuffercount) 103 End Sub DisplayState End Class CHoldIntegerSynchronized Figura 1.9 Il buffer condiviso sincronizzato

20 20 CAPITOLO 1 1 File: Producer.vb 2 Produce 4 interi e li pone nel buffer sincronizzato 3 4 Imports System.Threading 5 6 Public Class CProducer 7 Private sharedlocation As CHoldIntegerSynchronized 8 Private randomsleeptime As Random 9 10 costruttore 11 Public Sub New(ByVal sharedobject As _ 12 CHoldIntegerSynchronized, ByVal randomobject As Random) sharedlocation = sharedobject 15 randomsleeptime = randomobject 16 End Sub New registra i valori 1-4 nell oggetto sharedlocation 19 Public Sub Produce() 20 Dim count As Integer dorme per un periodo di tempo casuale fino a 3 secondi 23 imposta la proprietà Buffer di sharedlocation 24 For count = 1 To 4 25 Thread.Sleep(randomSleepTime.Next(3000)) 26 sharedlocation.buffer = count 27 Next Console.WriteLine(Thread.CurrentThread.Name & _ 30 done producing. & vbcrlf & Terminating & _ 31 Thread.CurrentThread.Name &. & vbcrlf) 32 End Sub Produce End Class CProducer Figura 1.10 Il produttore pone i valori interi nel buffer condiviso sincronizzato 1 File: Consumer.vb 2 Legge 4 valori interi nel buffer sincronizzato 3 4 Imports System.Threading 5 6 Public Class CConsumer 7 Private sharedlocation As CHoldIntegerSynchronized 8 Private randomsleeptime As Random 9 10 costruttore 11 Public Sub New(ByVal sharedobject As _ 12 CHoldIntegerSynchronized, ByVal randomobject As Random) sharedlocation = sharedobject 15 randomsleeptime = randomobject 16 End Sub New

21 MULTITHREADING legge quattro volte il valore di sharedlocation 19 Public Sub Consume() 20 Dim count, sum As Integer dorme per un periodo di tempo casuale (max 3 sec); aggiunge 23 a sum il valore della proprietà Buffer di sharedlocation 24 For count = 1 To 4 25 Thread.Sleep(randomSleepTime.Next(3000)) 26 sum += sharedlocation.buffer 27 Next Console.WriteLine(Thread.CurrentThread.Name & _ 30 read values totaling: & sum &. & vbcrlf & _ 31 Terminating & Thread.CurrentThread.Name &. & _ 32 vbcrlf) 33 End Sub Consume End Class CConsumer Figura 1.11 Il consumer legge i valori interi nel buffer condiviso sincronizzato 1 File: SharedCell.vb 2 Crea i thread produttore e consumatore 3 4 Imports System.Threading 5 6 Module modsharedcell 7 8 Sub Main() 9 10 crea l oggetto condiviso utilizzato dai thread 11 Dim holdinteger As New CHoldIntegerSynchronized() oggetto causale utilizzato dai thread 14 Dim randomobject As New Random() crea gli oggetti CProducer e CConsumer 17 Dim producer As New CProducer(holdInteger, randomobject) 18 Dim consumer As New CConsumer(holdInteger, randomobject) Console.WriteLine( {0, 35}{1, 9}{2} & vbcrlf, _ 21 Operation, Buffer, Occupied Count ) holdinteger.displaystate( Initial State ) crea i thread per il produttore e il consumatore 26 imposta i delegati per i thread 27 Dim producerthread As _ 28 New Thread(AddressOf producer.produce) Figura 1.12 I thread produttore e consumatore accedono in modo sincronizzato a un oggetto condiviso (continua)