Multithread Programming

Scrivere Applicazioni Multi Threading in .NET
Di Massimiliano Brolli

Premessa...................................................................................................3
Prerequisiti ................................................................................................3
Il Multi Threading .......................................................................................4
Le basi ......................................................................................................5
Il Namespace ..........................................................................................5
Le Dichiarazioni .......................................................................................5
Lanciare un thread ...................................................................................5
Meccanismi di Sincronizzazione ....................................................................6
Sleep......................................................................................................6
Start ......................................................................................................7
ResetAbort..............................................................................................7
Suspend .................................................................................................7
Resume ..................................................................................................7
Join........................................................................................................8
Interrupt.................................................................................................8
Abort......................................................................................................9
SpinWait............................................................................................... 10
Stato dei thread ....................................................................................... 11
La priorità dei thread..............................................................................13
Scopo delle variabili ...............................................................................15
Pool di Thread .......................................................................................... 18
Gli eventi................................................................................................. 22
I Timer.................................................................................................... 24
Apartment Thread e interoperabilità COM .................................................... 25
Conclusioni .............................................................................................. 27
Bibliografia .............................................................................................. 28

Premessa
Molto spesso ci siamo imbattuti nel termine AJAX, acronimo di Asynchronous
JavaScript and XML ovvero un sistema che permette alle pagine web di agire in
maniera asincrona.
Lo scopo di questo documento e far capire tramite semplici esempi le
componenti/funzionalità offerte da questo straordinario Framework messo a
disposizione anche in ambiente .NET.
Prerequisiti
Per procedere alla lettura di questo documento occorre aver letto le seguenti
dispense :
• Introduzione agli algoritmi.
• La scelta tra Microsoft.NET & Java
• Predisposizione Virtual Machine di base
• Predisposizione Virtual Machine per l'ambiente di sviluppo Microsoft .NET
• Introduzione alla scrittura del codice .NET
• Scrivere applicazioni .NET con Visual Studio
• Panoramica sulla programmazione ad oggetti
• La Storia
• Introduzione al Framework .NET
• Gli oggetti ADO.NET
• Predisposizione Ambiente SQL Server
• Applicazioni Windows Forms
• ADO.NET Entity Framework
• Scrivere ASP.NET Web Application, premessa e predisposizione
• Scrivere ASP.NET Web Application, La prima applicazione Web Forms
• Scrivere ASP.NET Web Application, I Web Services
• Scrivere ASP.NET Web Application, Applicazioni MVC
• Scrivere ASP.NET Web Application, AJAX

Il Multi Threading
Il MultiThreading comparso con Windows NT 3.1 e successivamente con Windows
95 rappresenta una rivoluzione nel campo informatico di largo consumo.
Solamente i linguaggi di basso livello prima dell’evento del Framework .NET
potevano realizzare applicazioni MultiThreading come ad esempio MSVC++ con
l’ausilio di particolari librerie.
In questo documento andremo ad analizzare le istruzioni che occorre imparare
per lavorare con i Thread utilizzando Microsoft.NET Framework 2.0 ed il
linguaggio VB.NET.
Un Thread o filo in inglese, rappresenta un processo che può lavorare
parallelamente al padre chiamante.
Nel framework.NET si può far lavorare in un Thread separato porzioni di codice
quali Sub Routine o intere classi per realizzare applicazioni performanti che
hanno come limite solamente la fantasia.
Addentrandoci nel documento cominceremo a familiarizzare con i meccanismi di
programmazione Asincrona che introdurranno problematiche nuove quali la
concorrenza applicativa e i meccanismi di sincronizzazione.

Le basi
Il Namespace
Per realizzare applicazioni MultiThreading occorre utilizzare il nameSpace
System.Threading come viene mostrato nell’esempio successivo.
Imports System.Threading
Le Dichiarazioni
Per lavorare con i Thread occorre dichiarare un oggetto di tipo ThreadStart che
permette di eseguire lo Start di un Thread e un oggetto Thread che ci
permetterà di crearlo.
Private _ThreadStart As ThreadStart
Private _Thread As Thread
Lanciare un thread
Come detto in precedenza è possibile far lavorare su un thread separato porzioni
di codice appartenenti ad una Sub Routine oppure una intera classe. Nell’esempio
successivo viene lanciato in un Thread separato una Sub Routine ClientGoSend.
L’istruzione _ClientThread.Start permetterà di lanciare il Thread come viene
mostrato nell’esempio successivo.
_ThreadStart = New ThreadStart(AddressOf ClientGoSend)
_Thread = New Thread(_ThreadStart)
_Thread.Start
Public sub ClientGoSend
End sub

Meccanismi di Sincronizzazione
I Thread essendo delle entità separate rispetto al processo chiamante che li ha
creati hanno una loro vita, questo vuol dire che mentre il padre effettuerà ad
esempio un loop infinito il Thread creato in precedenza prosegue in parallelo la
propria attività.
Questo meccanismo introduce alla programmazione Asincrona che seppur utile
aggiunge delle problematiche di sincronismo alle nostre applicazioni.
Il .NET Framework ci mette a disposizione dei metodi nella classe thread che
permettono di attendere per un determinato tempo un qualche evento oppure
ripartire nell’elaborazione allo scatenare di un altro.
Sleep
L’istruzione Thread.Sleep(100) mette in attesa il thread per un valore in
Millisecondi.
_ThreadStart = New ThreadStart(AddressOf Send)
_Thread.Start
Console.WriteLine(“Main” & AppDomain.GetCurrentThreadId())‘del thread Main
Public sub Send
Dim objThread As Thread = Thread.CurrentThread()
objThread.Sleep(100) ‘Mette in attesa il thread per 100 Millisecondi
Console.WriteLine(“Thread” & AppDomain.GetCurrentThreadId()) ‘ID del thread
objThread.Abort ‘Distrugge il Thread
End sub
L’istruzione Console.WriteLine(AppDomain.GetCurrentThreadId()) viene
ripetuta per due volte all’interno dell’applicazione perché stamperà a console
prima l’ID del processo chiamante e poi l’ID del processo chiamato.
Il risultato sarà
Main 2574
Thread 2575
Oppure
Thread 2575
Main 2574
Questo perchè potrà eseguire l’istruzione Console prima il Main oppure prima il
Thread creato.
Di seguito vengono riportati dei metodi della classe thread che servono per la
sincronizzazione dei Thread.

Start
L’istruzione Start lancia un thread.
ResetAbort
L’istruzione ResetAbort interrompe la distruzione di un thread.
Suspend
L’istruzione Suspend mette in attesa il thread.
Resume
L’istruzione Resume riattiva il thread.

Join
L’istruzione Join mette in attesa il thread.
Nell’esempio sotto riportato, il codice Main chiama un thread che terminirà allo
scadere di 4 secondi e scriverà “Worker End”.
Module Esempio01
Public Sub Worker()
Thread.Sleep(4000)
Console.WriteLine("Worker End")
End Sub
Sub Main()
_ThreadStart = New ThreadStart(AddressOf Worker)
_Thread.Start()
_Thread.Join() 'Attende che il thread sia completato
Console.WriteLine("Main End")
End Sub
End Module
Eseguendo il codice vedremo che il risultato sarà il seguente
Worker End
Main End
Questo perché il main attenderà il completamento del thread _Thread prima di
effettuare la scrittura di “Main End” grazie al metodo Join.
Se asterischiamo l’istruzione _Thread.Join() e rieseguiamo l’esempio noteremo che il
risultato sarà il seguente.
Main End
Worker End
Questo perché il Main non attenderà la conclusione del Thread _Thread che scriverà
dopo 4 secondo il messaggio “Worker End”
Il metodo Join può prendere in input un parametro espresso in millisecondi/Timestamp.
Tali millisecondi/Timestamp stanno ad indicare il tempo massimo che verrà atteso per la
terminazione del Thread.
Interrupt
L’istruzione Interrupt interrompe lo stato di attesa di un thread.

Abort
L’istruzione Abort distrugge il thread.
E’ da notare che tale istruzione non è una garanzia di distruzione in quanto genera al
suo interno un’eccezione di tipo ThreadAbortException e imposta lo stato su
AbortRequested.
Se all’interno di questa eccezione venisse invocato il metodo ResetAbort verrebbe
vanificata la chiamata di Abort precedentemente invocata e quindi è importante fare
attenzione al codice che stiamo implementando tenendo conto di questi meccanismi di
concorrenza.
La stessa cosa vale per il metodo Interrupt che a sua volta genera un’eccezione di tipo
ThreadInterruptedException e imposta lo stato su Running anche se interromperà
l’esecuzione.
Il codice seguente mostra il comportamento di quanto descritto sopra.
Module Esempio02
Sub Main()
_ThreadStart = New ThreadStart(AddressOf Worker)
_Thread.Start()
_Thread.Abort() 'Da provare cambiandolo in Interrupt
End Sub
Public Sub Worker()
Dim objThread As Thread = Thread.CurrentThread()
Try
Console.WriteLine("Worker Sleeping")
Thread.Sleep(4000)
'generata se invocato il metodo interrupt
Catch e As ThreadInterruptedException
Console.WriteLine("Worker interrupt : ThreadState " & _
Thread.CurrentThread.ThreadState.ToString)
'generata se invocato il metodo Abort
Catch e As ThreadAbortException
Console.WriteLine("Worker Abort : ThreadState " & _
'operazioni conclusive del costrutto Try/Catch
Finally
Console.WriteLine("Worker End : ThreadState " & _
End Try
Console.WriteLine("Worker Completed")
End Sub

End Module
Eseguendolo il risultato sarà il seguente
Worker Sleeping
Worker Abort : ThreadState AbortRequested
Worker End : ThreadState AbortRequested
Main End
Da notare che il thread non è stato completato ( non viene notificato “Worker
Completed”) in quanto è stata richiesta una operazione di Abort che viene anche
notificata dall’istruzione Thread.CurrentThread.ThreadState.ToString che ci
mostra lo stato del thread impostato su AbortRequested.
Se al posto di _ClientThread.Abort() inserissimo _ClientThread.Interrupt()
nel main del modulo il risultato cambierà in questo modo.
Worker Sleeping
Main End
Worker interrupt : ThreadState Running
Worker End : ThreadState Running
Worker Completed
Da notare che il motodo Interrupt ha interrotto l’esecuzione del thread senza
distruggerlo, infatti in questo esempio viene notificata la terminazione del thread
dal messaggio “Worker Completed” che ci avverte che l’invocazione di interrupt
ha interrotto lo stato di Sleep del thread.
SpinWait
L’istruzione SpinWait viene utilizzata su applicazione che girano su macchine
multiprocessore e costituisce un’alternativa al comando Sleep che restituisce cicli
di CPU rimanendo in attesa.

Stato dei thread
I Thread possono assumere diversi stati in funzione della loro sincronizzazione
con i processi chiamanti. In questa sezione andremo ad analizzare i diversi stati
per capirne meglio il loro utilizzo.
Come visto in precedenza, per acquisire lo stato di un thread occorre accedere al
metodo Shared Thread.CurrentThread.ThreadState.ToString che ci ritorna
un valore in formato Stringa dello stato corrente del thread.
Running
La parola stessa ci dice che il thread sta in esecuzione
Module Esempio03
Sub Main()
Dim _ThreadStart As New ThreadStart(AddressOf Worker)
Dim _Thread As New Thread(_ThreadStart)
_Thread.Start()
While True
Thread.Sleep(1000)
_Thread.ThreadState.ToString)
End While
End Sub
Public Sub Worker()
While True
End While
End Sub
End Module
WaitSleepJoin
Questo stato ci comunica che il thread si trova in uno stato di
Wait, Sleep o Join.
Module Esempio04
Sub Main()
_Thread.Start()
While True
Thread.Sleep(1000)
_Thread.ThreadState.ToString)
End While

End Sub
Public Sub Worker()
While True
Thread.Sleep(1000)
End While
End Sub
End Module
In questo caso è lo stesso Thread che sta effettuando un ciclo While
true ogni un secondo.
AbortRequested
La parola stessa ci dice che per il thread è stata invocata una
Abort.
Per il metodo Abort vi rimando all’esempio del metodo Abort nella
sezione Meccanismi di Sincronizzazione

La priorità dei thread
In un ambiente Multi Threading è possibile impostare una priorità di esecuzione
per ogni singolo thread. Tale meccanismo permette di condividere nel migliore
dei modi i cicli di CPU della macchina permettendo ai processi critici di avere una
maggiore priorità in termine di esecuzione sui processi secondari o di minor
importanza applicativa.
I processi Microsoft .NET sono di due tipi, processi di Foreground e processi di
Background.
Ai processi di Foreground possiamo attribuire una priorità di esecuzione in base
ad una Enumerazione contenuta nella classe System.threading.ThreadPriority
qua sotto ricreata per maggiore chiarezza.
‘Enumeration che riporta le priorità per i thread di Foreground
Public Enum Priority
Lowest = 0
BelowNormal = 1
Normal = 2
AboveNormal = 3
Highest = 4
End Enum
Nell’esempio successivo abbiamo utilizzato il metodo Priority per assegnare una
priorità di esecuzione. E’ importante dire che un Thread creato dal Runtime senza
specifica di priorità viene creato come Foreground di tipo Normal.
Module Esempio05
Sub Main()
_Thread.Start()
_Thread.Priority = ThreadPriority.Lowest
End Sub
Public Sub Worker()
Thread.Sleep(4000)
Console.WriteLine("Worker Completed, Priority is : " & _
Thread.CurrentThread.Priority.ToString)
End Sub
End Module
Il risultato di questo esempio ritornerà il seguente Output.

Worker Completed, Priority is : Lowest
Main End
Cambiando il tipo di Priorità da Lowest a Highest noteremo che l’applicazione
attenderà sempre la conclusione del thread prima di essere terminata
(Ovviamente omettendo il metodo Join).
Questo perché si tratta di un thread di tipo Foreground e quindi deve essere per
forza terminato prima di terminare l’intero processo.
E’ possibile definire un Thread come processo di Background utilizzando la
proprietà Thread.IsBackground di tipo Boleano.
Impostando a True questo valore il processo potrà essere terminato in qualsiasi
momento, talei processi di background saranno processi non di vitale importanza
per le nostre applicazioni.
Module Esempio06
Sub Main()
_Thread.Start()
_Thread.IsBackground = True
End Sub
Public Sub Worker()
Thread.Sleep(4000)
Console.WriteLine("Worker Completed, Priority is : " & _
Thread.CurrentThread.Priority.ToString)
End Sub
End Module
Main End
Questo perchè il processo figlio è stato definito di Background e quindi è stato
terminato senza preavviso dal processo chiamante.

Scopo delle variabili
E’ possibile creare delle variabili che avranno uno scopo limitato al processo che
le sta eseguendo. Nell’esempio che viene riportato in seguito, la variabile di
classe Value viene dichiarata inserendo il suffisso <ThreadStatic()>. Questa
variabile non sarà più una variabile condivisa sia dal processo chiamante che dal
processo figlio, ma ogni processo avrà una copia di tale variabile e ne potrà fare
un uso esclusivo.
Module Esempio07
<ThreadStatic()> Public Value As String = "Main"
Sub Main()
Console.WriteLine("Main Value = " & Value)
_Thread.Start()
_Thread.Join()
Console.WriteLine("Main Value = " & Value)
End Sub
Public Sub Worker()
Console.WriteLine("Worker Value = " & Value)
Value = "Worker"
Console.WriteLine("Worker Value = " & Value)
End Sub
End Module
Main Value = Main
Worker Value =
Worker Value = Worker
Main Value = Main
Main End
Vediamo come la variabile Value impostata a “Main” sarà visibile solamente nel
Main del programma, mentre il Thread Worker ne potrà fare un uso esclusivo
impostando un valore che non verrà condiviso con il programma Main chiamante.
E’ possibile utilizzando I Thread definire dei punti di codice nel quale non possono
accedervi più Thread contemporaneamente.
Questo è possibile grazie all’istruzione SyncLock.
Nell’esempio successivo verrà definita una variabile di classe di nome Lock e nel
metodo Worker verrà utilizzata l’istruzione SyncLock Lock che tramite l’oggetto
globale Lock determinerà chi far accedere alla porzione di codice specifica.

L’oggetto Lock deve essere definito di tipo Object.
Module Esempio15
Public Counter As Integer
Public Lock As New Object
Sub Main()
Dim i As Integer
For i = 0 To 10
_Thread.Start()
Next
End Sub
Public Sub Worker()
‘SyncLock Lock
Counter = Counter + 1
Thread.Sleep(New Random().Next(500, 2000))
Console.WriteLine("Worker Counter : " & Counter)
‘End SyncLock
End Sub
End Module
Questo perché la display del contatore avverrà dopo che tutti i thread avranno
effettuato la somma.
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Worker Counter : 11
Se disasterischiamo le istruzioni SyncLock e rieseguiamo l’esempio vedremo che
il risultato cambierà in questo modo.
Worker Counter : 1
Worker Counter : 2
Worker Counter : 3
Worker Counter : 4
Worker Counter : 5
Worker Counter : 6
Worker Counter : 7
Worker Counter : 8
Worker Counter : 9
Worker Counter : 10
Worker Counter : 11

Questo perché il blocco di codice ha un lock determinato dall’oggetto Lock
definito come variabile di classe che ne restituisce il sincronismo.
Da notare che il primo thread accederà al blocco e gli altri rimarranno in attesa
fino a quando il primo thread non accederà all’istruzione End SyncLock, a quel
punto il secondo entrerà in azione e così via.

Pool di Thread
I Pool di Thread vengono in nostro aiuto quando occorre creare dei processi di
lunga durata che lavorano in parallelo. Un classico esempio sono quelle
applicazioni Server (Web Server, SMTP Server ecc..) che non possono smaltire
una richiesta alla volta ma debbono prendere in carico le richieste e processarle
in parallelo.
Quindi l’utilizzo di Pool di Thread risulta complesso e oneroso in termine di carico
di CPU e quindi se non espressamente richiesto ne faremo volentieri a meno.
A nostro aiuto viene la classe ThreadPool che ci consente di creare Thread
tramite l’ausilio del metodo QueueUserWorkItem. Tutti i Thread creati da un
ThreadPool vengono avviati con Priority di Background.
Module Esempio08
Sub Main()
Dim i As Integer
For i = 0 To 10
ThreadPool.QueueUserWorkItem( _
New WaitCallback(AddressOf Worker), i)
Next
Console.WriteLine("Main id : " & _
AppDomain.GetCurrentThreadId())
Thread.Sleep(5000)
End Sub
Public Sub Worker(ByVal IndexThread As Object)
Console.WriteLine("Thread N° " & IndexThread & " id : " & _
End Sub
End Module
In questo esempio vengono creati tramite la classe ThreadPool dei thread di
tipo Worker che verranno eseguiti parallelamente.
Il risultato prodotto sarà il seguente.
Main id : 2008
Thread N° 0 id : 532

La cosa che ci viene subito all’occhio è che l’ID dei thread lanciati sono sempre gli
stessi.
Questo perché appena verrà accodato (i = 0) al ThreadPool una nuova
richiesta, il ThreadPool creerà un nuovo Thread e lo eseguirà. Se in un tempo
relativamente breve il Thread verrà terminato, il ThreadPool riutilizzerà lo
stesso Thread per l’elaborazione della coda successiva (i=1 , i=2, i=3. i=4 ecc..)
Quindi l’ID dei Thread processati sarà sempre lo stesso in quanto verrà
riutilizzata la stessa allocazione di memoria e quindi non verrà effettuato un vero
parallelismo di applicazione.
Ovviamente assumere che il termine dei Thread avvenga in modo lineare è
estremamente pericoloso (N°1, N°2, N°3, N°4, N°5, N°6, N°7, N°8, N°9, N°10)
Il codice successivo invece mostra un vero parallelismo applicativo in quanto il
termine dei Thread creati dal ThreadPool avrà un tempo di durata maggiore
del tempo minimo di esecuzione di un Thread.
Questo permetterà al ThreadPool di creare Thread con ID differenti e farli
lavorare in parallelo.
L’istruzione Thread.Sleep(New Random().Next(2000)) ci permette di
simulare una durata casuale della funzione Worker.
Module Esempio09
Sub Main()
Dim i As Integer
For i = 0 To 10
Next
Console.WriteLine("Main id : " & AppDomain.GetCurrentThreadId())
Thread.Sleep(5000)
End Sub
Thread.Sleep(New Random().Next(2000))
End Sub
End Module
Il risultato prodotto sarà il seguente.

Ovviamente alcuni Thread potranno essere riutilizzati dal ThreadPool e quindi
manterranno ID analoghi.
Il ThreadPool ha dei metodi che possono essere invocati per facilitare il suo
utilizzo.
Di default il numero massimo di esecuzione parallela è impostato a 25 Thread
che tramite il metodo SetMaxThreads può essere variato.
Dim MaxThread As Boolean = ThreadPool.SetMaxThreads(100, 1)
restituisce un valore di tipo Boleano se la richiesta è andata a buon fine.
Tale metodo prende in input due valori, Workerthreads che definisce il numero
massimo di thread presenti nel Pool e completionPortThreads che prende in
input un numero corrispondente alle CPU sulle quali si vuole far girare il Pool.
Ovviamente una volta terminato il numero di Thread massimi in esecuzione nel
Pool, le richieste rimarranno in sospeso fino al liberarsi di un Thread
appartenente al Pool.
L’esempio successivo invece utilizza il metodo SetMaxThreads e
GetAvailableThreads che ritorna il numero dei thread disponibili all’interno del
Pool. Tale valore è la sottrazione tra il numero massimo dei Thread impostati
tramite SetMaxThreads e il numero dei thread in esecuzione.
Module Esempio10
Sub Main()
Dim i As Integer
Dim MaxThread As Boolean = ThreadPool.SetMaxThreads(10, 1)
Console.WriteLine("SetMaxThreads : " & MaxThread)
For i = 0 To 10
Dim ReturnAddTopool As Boolean = _
Next
Thread.Sleep(5000)
End Sub
Thread.Sleep(New Random().Next(2000))
Dim WorkerThreads As Integer
Dim ThreadId As Integer = AppDomain.GetCurrentThreadId()
Dim CompletionPortThreads As Integer
ThreadPool.GetAvailableThreads(WorkerThreads, _
CompletionPortThreads)
Console.WriteLine("Thread Available is : " & _
WorkerThreads)

ThreadId)
End Sub
End Module
Il risultato sarà il seguente.
SetMaxThreads : True
Thread Available is : 9
Come vediamo Thread Available è variabile in base a diversi fattori, la cosa che
salta subito all’occhio e che ci saremmo aspettati dalle print del 2 thread che i
Thread disponibili siano minori di 9. Come visto in precedenza il ThreadPool
definisce un tempo entro il quale allocare una seconda risorsa per attivare un
nuovo Thread.
Se la precedente richiesta finisce entro un tempo relativamente breve riutilizza la
stessa (e per questo mantiene anche lo stesso ID di processo).

Gli eventi
Fino ad ora abbiamo creato un Thread passandogli un indirizzo di una Sub
Routine dichiarata all’interno della funzione Main(), come detto in precedenza è
possibile istanziare una classe, passargli dei parametri e poi eseguire in un
thread separato una Routine presente di quella classe.
Nell’esempio successivo viene dichiarata una classe che al suo interno dispone di
un evento TerminateThread che verrà generato per segnalare al Main() il
completamento delle operazioni.
Module Esempio11
Public WithEvents _Worker As Worker
Sub Main()
_Worker = New Worker
_Worker.TimeSleep = 2000
Dim _ThreadStart As New ThreadStart(AddressOf _Worker.Start)
_Thread.Start()
End Sub
Private Sub _Worker_TerminateThread(ByVal Result As String) _
Handles _Worker.TerminateThread
Console.WriteLine(Result)
End Sub
End Module
Public Class Worker
Public Event TerminateThread(ByVal Result As String)
Public TimeSleep As Integer
Public Sub Start()
Thread.Sleep(TimeSleep)
RaiseEvent TerminateThread("Worker Completing. TimeSleep is : " & _
TimeSleep)
End Sub
End Class
I risultato dell’elaborazione è il seguente
Main End
Worker Completing. TimeSleep is : 2000
Questo meccanismo di segnali ci permetterà di avere un controllo preciso su ciò
che sta succedendo all’interno del Thread.
Ma è possibile anche mettere in attesa un Thread fino a che non si verifichi una
condizione per cui far continuare l’elaborazione senza utilizzare i comandi di
sincronizzazione Suspend e poi il relativo Resume.

Nel codice successivo utilizzeremo il comando AutoResetEvent che ci permette
di utilizzare i metodi WaitOne() e Set() con cui mettere in attesa un Thread
(WaitOne) e poi successivamente dal Main far continuare l’elaborazione (Set).
Oltre a WaitOne() è possibile mettere in attesa il Thread tramite WaitAny() e
WaitAll().
WaitAny() mette in attesa il Thread fino a quando un evento venga segnalato.
WaitAll() invece mette in attesa il Thread fino a che tutti gli eventi vengano
segnalati.
Ovviamente l’evento viene segnalato quando viene evocato il metodo Set().
Questo genere di meccanismi ci permettono di controllare perfettamente il codice
che viene processato all’interno dei Thread.
Module Esempio12
Public _AutoResetEvent As AutoResetEvent
Sub Main()
_AutoResetEvent = New AutoResetEvent(False)
Console.WriteLine("Main : Start Thread")
_Thread.Start()
Console.WriteLine("Main Slepp 1 Second...")
Thread.Sleep(1000)
Console.WriteLine("Main Signal Worker Thread")
_AutoResetEvent.Set()
End Sub
Public Sub Worker()
Console.WriteLine("Worker thread Active")
_AutoResetEvent.WaitOne()
Console.WriteLine("Worker thread Completing")
End Sub
End Module
I risultato dell’elaborazione è il seguente
Main : Start Thread
Worker thread Active
Main Slepp 1 Second...
Main Signal Worker Thread
Worker thread Completing

I Timer
Il nameSpace System.Threading comprende un oggetto molto utile che
andremo ad analizzare che si chiama Timer.
Il timer viene in nostro aiuto quando occorre far eseguire porzioni di codice a
tempo.
Nell’esempio successivo viene mostrato l’utilizzo di un timer, da tenere in
considerazione che questo tipo di classe può essere utilizzata anche all’interno
dei Windows Service quando non è possibile utilizzare la classe Timer presente
nelle Windows Form.
Il costruttore della classe Timer prende in input un oggetto di tipo
TimerCallBack che identifica la locazione di memoria da andare ad eseguire, lo
State, un oggetto contenente i valori da passare al metodo da eseguire,
dueTime che specifica il tempo che verrà calcolato prima della prima chiamata
(0 vuol dire subito) e infine il Period che corrisponde al tempo in millisecondi tra
una chiamata e l’altra.
Module Esempio13
Sub Main()
Dim _TimerCallback As New TimerCallback(AddressOf Worker)
Dim _Timer As Timer = New Timer(_TimerCallback, _
Nothing, _
0, _
1000)
Thread.Sleep(6000)
End Sub
Public Sub Worker(ByVal State As Object)
Console.WriteLine("Worker Now : " & DateTime.Now.ToLongTimeString())
End Sub
End Module
Worker Now : 9.27.43

Apartment Thread e interoperabilità COM
In ultima analisi vediamo in che maniera far collaborare i Thread .NET con il
vecchio mondo COM. Per questo motivo avremo senz’altro notato delle proprietà
presenti all’interno dell’oggetto Thread denominate SetApartmentState() e
GetApartmentState().
L’Apartment State è un contenitore logico presente in un processo dove sono
allocati oggetti che condividono gli stessi requisiti di accesso ad un Thread.
Tele specifica esiste nella vecchia COM ma non è presente all’interno del
Common Language Runtime di .NET. I Componenti COM grazie all’Apartment
garantivano una corretta sincronizzazione delle risorse e per questa loro logica di
implementazione che occorre modificare i nostri Thread se vogliamo far uso di
componenti COM dal loro interno.
La proprietà SetApartmentState() prende in input i valori dati
dall’enumerazione riportata in seguito per comodità.
Public Enum ApartmentState
STA = 0 'Single thread Apartment
MTA = 1 'MultiThread Apartment
unknow = 2 'Non definito
End Enum
Se non viene dichiarato un ApartmentState() lo stato prelevato dalla proprietà
GetApartmentState() sarà impostato su unknow. l’oggetto COM se noterà un
Apartment incompatibile utilizzerà un proxy per farlo lavorare correttamente.
Per migliorare le performance di comunicazione tra il thread chiamante e
l’oggetto COM è meglio specificare il corretto stato di Apartment da utilizzare.
Non è possibile modificare una volta avviato il Thread lo stato di Apartment ne
annullarne l’inizzializzazione.
Imports ComDemo
Module Esempio14
Sub Main()
Try
Console.WriteLine("Worker ApartmentState : " & _
_Thread.GetApartmentState.ToString)
_Thread.TrySetApartmentState(ApartmentState.STA)
Console.WriteLine("Worker ApartmentState : " & _
_Thread.GetApartmentState.ToString)

_Thread.Start()
Catch ex As ThreadStateException
Console.WriteLine("ThreadStateException occurs " & ex.Message)
End Try
_Thread.Join()
End Sub
Sub Worker()
Dim ComObject As New ComDemo.Class1
Console.WriteLine("Worker invoke SetValue")
ComObject.SetValue("Inizialize")
Thread.Sleep(2000)
Dim ComValue As String = ComObject.GetValue
Console.WriteLine("Worker invoke GetValue : " & ComValue)
End Sub
End Module
Worker ApartmentState : Unknown
Worker ApartmentState : MTA
Worker invoke SetValue
Worker invoke GetValue : Inizialize
Questo esempio fa vedere che è possible impostare l’ApartmentState
solamente in fase di creazione del thread prima di aver invocato il metodo
Start().

Conclusioni
Il MultiThreading in Microsoft .NET è possibile ed è di semplice utilizzo come
abbiamo appreso in questo documento.
Le tecniche di Pool di thread già presenti all’interno del Framework facilitano di
gran lunga la realizzazione e la progettazione di applicativi scalabili e performanti
che fino ad ora erano onerosi e complessi da realizzare.
Al programmatore è rivolta la massima accortezza nello scrivere le applicazioni
che con l’avvento del MultiThreading introducono meccanismi complessi di
tracciamento dei processi e di Locking.

Multithread Programming

More Related Content

Similar to Multithread Programming (20)

Multithread Programming