Programmazione di Sistema

Transcript

1 Programmazione di Sistema Massimo Bernaschi Istituto per le Applicazioni del Calcolo Mauro Picone Consiglio Nazionale delle Ricerche Viale Manzoni, Rome - Italy m.bernaschi@iac.cnr.it

2 Threads e Scheduling in Win32 I thread sono l unità fondamentale di esecuzione in Win32. I thread all interno di un processo condividono gli stessi dati e lo stesso codice. Ogni thread ha un proprio stack e può ricevere un parametro (tipicamente un puntatore) all atto della creazione. Ogni thread può allocare un proprio Thread Local Storage che rimane privato (ma globale). Solo sui sistemi Windows NT, 2000/3, XP è possibile allocare i thread su più processori. 2

3 Per creare un nuovo thread: HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpthreadattributes, SIZE_T dwstacksize, LPTHREAD_START_ROUTINE lpstartaddress, LPVOID lpparameter, DWORD dwcreationflags, LPDWORD lpthreadid); la dimensione dello stack di default del nuovo thread è uguale a quella del processo che invoca la CreateThread. Normalmente la dimensione è 1 MB; con 0 si richiede che lo stack abbia dimensione uguale allo stack del chiamante. notare come viene tornato sia un handle sia un identificatore (lpthreadid) del nuovo thread; lpstartaddress punta ad una funzione che accetta un singolo puntatore e ritorna un exit code (DWORD a 32 bit) 3

4 (DWORD WINAPI ThreadFunc(LPVOID)); se dwcreationflags è uguale a CREATE SUSPENDED, il thread non va in esecuzione immediatamente ma deve essere attivato con la ResumeThread; Un thread termina quando completa l esecuzione la funzione puntata da lpstartaddress. La terminazione può avvenire anche invocando la funzione VOID ExitThread(DWORD dwexitcode); Un thread può terminare un altro thread con la funzione: BOOL TerminateThread( HANDLE hthread, DWORD dwexitcode); ma questa tecnica è fortemente scoraggiata (non vengono liberate le risorse del thread, non vengono eseguiti i completion handler...). 4

5 Il codice di ritorno di un thread può essere ottenuto con la: BOOL GetExitCodeThread( HANDLE hthread, LPDWORD lpexitcode); notare che se il thread è ancora running viene ritornato STILL ACTIVE. Come nel caso dei processi, è possibile accedere ad un thread usando la funzione HANDLE OpenThread( DWORD dwdesiredaccess, BOOL binherithandle, DWORD dwthreadid); Ogni thread ha un suspend count e può andare in esecuzione solo se questo contatore vale zero. ricordare come un thread può essere creato nello stato suspended (il suspend count vale 1 in questo caso); 5

6 le funzioni per la manipolazione del suspend count sono: DWORD SuspendThread(HANDLE hthread) e DWORD ResumeThread(HANDLE hthread). Notare come per l attesa della terminazione di un thread si utilizzano le stesse primitive dei processi: WaitForSingleObject e WaitForMultipleObject (con quest ultima si può attendere la terminazione di un massimo di 64 thread). la funzione HANDLE CreateRemoteThread( HANDLE hprocess, LPSECURITY_ATTRIBUTES lpthreadattributes, SIZE_T dwstacksize, LPTHREAD_START_ROUTINE lpstartaddress, LPVOID lpparameter, DWORD dwcreationflags, LPDWORD lpthreadid); 6

7 permette di creare un thread che gira nello spazio di indirizzamento del processo specificato da hprocess (è supportata solo su Windows NT, ). Le principali differenze per quanto riguarda la creazione dei thread Win32 con i pthreads sono: non esiste una primitiva per sospendere un altro pthread; non è possibile creare un pthread in un altro processo; i pthread permettono di terminare in maniera pulita un altro thread (con la primitiva pthread cancel) mentre nel caso di Win32, la terminazione, come detto, non esegue tutte le operazioni di cleanup (ad esempio l invocazione dei completion handler). 7

8 Libreria C e Threads in Win32 È necessario controllare che le primitive della libreria C utilizzate siano thread-safe, cioè che possano essere invocate da più thread che fanno parte dello stesso processo. un esempio di funzione non thread-safe è la strtok (char *strtok(char *s, const char *delim)) che può essere utilizzata per effettuare il parsing di una stringa. Questa funzione non è thread-safe perché utilizza un buffer di memoria allocato in una zona dello spazio di indirizzamento accessibile a tutti i thread del processo. Il C Microsoft fornisce un implementazione della libreria C (LIBCMT.LIB) che è garantita essere thread-safe. In questo caso la creazione del thread avviene con la funzione beginthreadex invece della CreateThread. 8

9 gli argomenti della beginthreadex sono esattamente gli stessi della CreateThread ma è necessario fare un cast del valore di ritorno a HANDLE Per terminare il thread si deve utilizzare endthreadex al posto di ExitThread. Attenzione: non usare le funzioni beginthread e endthread Attenzione (2): definire la macro MT se si usa il Visual C++. 9

10 Codice rientrante e thread-safety Una funzione rientrante non mantiene dati statici e non ritorna un puntatore a dati statici. Tutti i dati sono forniti dal chiamante alla funzione chiamata. Una funzione rientrante non deve invocare funzioni non rientranti. Una funzione thread-safe protegge le risorse condivise tramite lock. Una funzione che non usa dati statici o altre risorse condivise è (banalmente) thread-safe int diff(int x, int y) { /* threadsafe function */ int delta; delta = y - x; if (delta < 0) delta = -delta; return delta; } 10

11 Merge-sort con threads Esempio: sortmtx.c (CHAPTR08). 11

12 Thread Local Storage (TLS) Win32 mette a disposizione un insieme di puntatori privati per ogni thread. Questi permettono ad ogni thread di accedere zone di memoria globale private. Inizialmente non è allocato nessun indice per il TLS. 12

13 Un nuovo indice è allocato con la funzione: DWORD TlsAlloc(VOID) Possono essere allocati almeno fino a 64 indici. Se non sono più disponibili indici viene ritornato 1. Il valore corrispondente ad una slot del TLS può essere ottenuto e definito con le funzioni: LPVOID TlsGetValue(DWORD dwtlsindex); BOOL TlsSetValue( DWORD dwtlsindex, LPVOID lptlsvalue); ovviamente dwtlsindex deve essere stato allocato con TlsAlloc. Per liberare un indice: BOOL TlsFree(DWORD dwtlsindex); Sebbene nessun thread può accedere il TLS di un altro thread, 13

14 qualsiasi thread può invocare TlsFree distruggendo in questo modo l indice per tutti i thread. Il TLS è frequentemente usato all interno delle DLL. esempio: tls.c (locale) 14

15 Priorità e Scheduling Il kernel di Windows esegue sempre il thread con priorità più alta. Esistono quattro classi di priorità: 1. IDLE PRIORITY CLASS: priorità base 4 2. NORMAL PRIORITY CLASS: priorità base 9 o 7 Se la finestra ha il focus la priorità base è 9 altrimenti è HIGH PRIORITY CLASS: priorità base REALTIME PRIORITY CLASS: priorità base 24 Notare come le priorità, al contrario di Unix/Linux, sono definite in ordine decrescente, valori più alti corrispondono a priorità superiori. La prima e l ultima classe sono usate raramente. Un processo può conoscere o modificare la propria priorità o 15

16 quella di un altro processo tramite le funzioni: BOOL SetPriorityClass( HANDLE hprocess, DWORD dwpriorityclass); DWORD GetPriorityClass( HANDLE hprocess); sono necessari i diritti di PROCESS SET INFORMATION e PROCESS QUERY INFORMATION rispettivamente sul processo hprocess. Le priorità dei thread sono definite rispetto alla priorità base del processo. Alla creazione, la priorità del thread è uguale a quella del processo L intervallo di variabilità è ±2 dalla priorità base del processo. 16

17 THREAD PRIORITY LOWEST, THREAD PRIORITY BELOW NORMAL, THREAD PRIORITY NORMAL, THREAD PRIORITY ABOVE NORMAL, THREAD PRIORITY HIGHEST. Esistono inoltre due priorità assolute : THREAD PRIORITY IDLE con valore 1 THREAD PRIORITY TIME CRITICAL con valore 15 usate però solo per casi particolari. Le funzioni per definire le priorità dei thread sono: BOOL SetThreadPriority( HANDLE hthread, int npriority); int GetThreadPriority(HANDLE hthread); notare come per i thread le priorità siano definite come int invece di DWORD. 17

18 Ricordare che le priorità dei thread cambiano automaticamente con quelle dei processi relativi. Tramite la funzione VOID Sleep(DWORD dwmilliseconds); un thread può rilasciare il processore ed entrare nello stato wait per uno periodo di tempo specificato da dwmilliseconds. se dwmilliseconds è uguale a zero, il thread rilascia il processore ma non entra nello stato wait. 18

19 Possibili problemi con i thread Ricordare che i thread vanno in esecuzione in maniera asincrona. Non c e un ordinamento nell esecuzione, a meno che questo non venga imposto esplicitamente dall applicazione. 1. non fare mai assunzioni sull ordine con cui un thread che invoca CreateThread ed il thread creato da questa chiamata vanno in esecuzione; 2. in caso di necessità creare il thread nello stato SUSPENDED e riesumarlo esplicitamente al momento opportuno; 3. l area di memoria puntata dal parametro passato all atto della CreateThread deve essere riservata per ogni singolo thread; 4. non usare le priorità dei thread come meccanismo di sincronizzazione; 19

20 5. usare i thread quando ha senso. Se un applicazione ha natura sequenziale i thread aggiungono solo complessità. 20

21 Stati possibili per un thread 21

22 Fibre in Win32 Una fibra è una parte di un thread che può essere schedulata dall applicazione invece che dal kernel. un thread può creare più fibre e le fibre stesse determinano quale sarà eseguita successivamente; le fibre hanno stack indipendenti ma condividono il TLS del thread; la gestione delle fibre avviene interamente a livello utente fuori dal kernel; le fibre sono disponibili solo su Windows NT, 2000, XP...; uno degli utilizzi più comuni delle fibre è quello di fare polling su una risorsa (ad esempio un lock, un mutex,...) e passare il controllo ad un altra specifica fibra se la risorsa non è disponibile. 22

23 In questo modo si evita di bloccare l intero thread; le fibre permettono di implementare il concetto di co-routine. In altre parole l applicazione tieni attivi più task e passa il controllo esplicitamente a quello che ritiene più opportuno (ricordare che il programmatore non può decidere quale thread deve prendere il controllo della CPU). 23

24 L API per le fibre è costituita da 6 primitive. La sequenza logica di utilizzo è la seguente: 1. Il thread deve per prima cosa abilitare le operazioni sulle fibre: LPVOID ConvertThreadToFiber( LPVOID lpparameter); il thread consiste a questo punto di una singola fibra primaria. lpparameter ha lo stesso ruolo dell argomento passato ad un thread all atto della creazione; il valore di ritorno è l indirizzo della fibra (gioca in qualche modo il ruolo di un handle); 2. La fibra primaria (o qualsiasi altra fibra successivamente) crea nuove fibre tramite la funzione: LPVOID CreateFiber( SIZE_T dwstacksize, LPFIBER_START_ROUTINE lpstartaddress, LPVOID lpparameter); 24

25 il significato degli argomenti è del tutto simile al caso della CreateThread. Notare che il valore di ritorno (che è un indirizzo) non deve concidere con lpstartaddress che è il puntatore alla funzione iniziale; la funzione iniziale deve essere VOID perché un return terminerebbe l intero thread (VOID WINAPI FiberFunction(LPVOID lpparameter)). 3. Una fibra passa il controllo ad un altra fibra tramite la funzione: VOID SwitchToFiber(LPVOID lpfiber); dove lpfiber è l indirizzo della fibra che deve essere eseguita; notare come l esecuzione della fibra che invoca SwitchToFiber riprende dall istruzione successiva alla chiamata solo quando un altra fibra ripassa il controllo a questa esplicitamente; 25

26 4. Una fibra può conoscere il valore dell argomento che le è stato passato o il proprio indirizzo con le macro: PVOID GetFiberData(void); PVOID GetCurrentFiber(void); 5. Infine una fibra può cancellare un altra fibra con la funzione: VOID DeleteFiber(LPVOID lpfiber); se l indirizzo della fibra è lo stesso della fibra chiamante, l intero thread viene terminato; se viene cancellata una fibra che fa parte di un altro thread i risultati sono impredicibili; Recentemente è stato introdotto il concetto di Fiber Local Storage, simile a quello del Threads Local Storage. Esempio: 26

27 Sincronizzazione dei thread in Win32 I meccanismi di sincronizzazione in Win32 possono essere utilizzati non solo tra thread all interno dello stesso processo ma, in molti casi, anche tra thread appartenenti a processi separati. Alcune semplici regole generali sono le seguenti: 1. I thread dovrebbero cambiare il process environment solo nel caso in cui tutti i thread devono essere impattati. 2. Se una funzione deve mantenere un valore attraverso chiamate successive, è necessario allocare la relativa variabile nel TLS o comunque in una struttura dati dedicata per ogni thread. 3. Le variabili che devono essere effettivamente condivise dovrebbero essere dichiarate con lo storage modifier volatile. 27

28 Le più semplici funzioni di sincronizzazione che risolvono comunque un problema molto comune sono: LONG InterlockedIncrement(LONG volatile* Addend); LONG InterlockedDecrement(LONG volatile* Addend); queste funzione incrementano e decrementano di 1 il valore della locazione (a 32 bit) puntata da Addend. 28

29 CRITICAL SECTION La CRITICAL SECTION implementa il relativo concetto ed è un oggetto mantenuto nello spazio utente. A differenza di altri meccanismi di sincronizzazione non può essere utilizzato tra processi. La sezione critica è controllata da una variabile di tipo CRITICAL SECTION (CS). Un solo thread per volta può essere in una specifica CS. Per inizializzare e rimuovere una CRITICAL SECTION void InitializeCriticalSection(LPCRITICAL_SECTION lpcriticalsection); void DeleteCriticalSection(LPCRITICAL_SECTION lpcriticalsection); La funzione void EnterCriticalSection(LPCRITICAL_SECTION lpcriticalsection); blocca il thread che la invoca se un altro thread è nella 29

30 sezione. Il thread viene sbloccato quando l altro thread invoca void LeaveCriticalSection(LPCRITICAL_SECTION lpcriticalsection); Se un thread già ha il controllo di una CS può entrare più volte senza essere bloccato. Viene mantenuto un contatore ed il thread deve lasciare la CS tante volte quante è entrato. Invocare la LeaveCriticalSection per una sezione che non si controlla produce risultati impredicibili. Non esiste un meccanismo di timeout per la EnterCriticalSection, tuttavia la funzione: BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpcriticalsection); permette di tentare di prendere il controllo della CS. 30

31 CRITICAL_SECTION CriticalSection; // Global variable void main() { // Initialize the critical section one time only. if (!InitializeCriticalSectionAndSpinCount(&CriticalSection, 0x ) return;... // Release resources used by the critical section object. DeleteCriticalSection(&CriticalSection) } DWORD WINAPI ThreadProc( LPVOID lpparameter ) {... // Request ownership of the critical section. EnterCriticalSection(&CriticalSection); // Access the shared resource. } // Release ownership of the critical section. LeaveCriticalSection(&CriticalSection);... 31

32 esempio: simplepc.c in chaptr09 32

33 Mutex Un mutex fornisce funzionalità più avanzate delle CRITICAL SECTION possono essere utilizzati anche tra thread appartenenti a processi distinti; sono gestiti tramite handle; permettono di definire un time-out; viene gestita dal sistema la terminazione di un thread che controlla un mutex: la WaitForSingleObject ritorna WAIT ABANDONED 0; come per le CS, è possibile acquisire un mutex più volte ed in questo caso il mutex va rilasciato esplicitamente lo stesso numero di volte; Per creare un mutex: 33

34 HANDLE CreateMutex( LPSECURITY_ATTRIBUTES lpmutexattributes, BOOL binitialowner, LPCTSTR lpname); binitialowner se uguale a TRUE garantisce al thread chiamante l immediato controllo del mutex lpname. lpname fa parte dello stesso name space degli eventi, semafori e file mapping che è distinto da quello del file system ed ha altre caratteristiche. Per accedere un mutex già esistente in un altro processo: HANDLE OpenMutex( DWORD dwdesiredaccess, BOOL binherithandle, LPCTSTR lpname); 34

35 Per ottenere il controllo di un mutex si usa la DWORD WaitForSingleObject( HANDLE hhandle, DWORD dwmilliseconds); o la WaitForMultipleObject. Come al solito, dwmilliseconds uguale a 0 corrisponde a fare polling senza rimanere bloccati Per rilasciare il controllo di un mutex: BOOL ReleaseMutex(HANDLE hmutex); (ovviamente funziona solo se il thread ha effettivamente il controllo) 35

36 Semafori In Win32 esistono semafori che mantengono un contatore. l oggetto semaforo è segnalato quando il contatore è più grande di zero; un thread rimane in attesa quando il contatore ha valore 0. le primitive sono simili a quelle per il mutex: per la creazione HANDLE CreateSemaphore( LPSECURITY_ATTRIBUTES lpsemaphoreattributes, LONG linitialcount, LONG lmaximumcount, LPCTSTR lpname); Il valore del contatore è sempre 0 e lmaximumcount l acquisizione avviene sempre con la WaitForSingleObject. È possibile decrementare il contatore solo di un unità 36

37 con una singola operazione di wait. Il rilascio del semaforo che avviene con la funzione: BOOL ReleaseSemaphore( HANDLE hsemaphore, LONG lreleasecount, LPLONG lppreviouscount); permette invece di incrementare il valore del contatore di un valore qualsiasi fino al massimo consentito dal semaforo. Notare come un valore superiore al massimo consentito provochi un errore senza modificare il valore del contatore. Notare come non è assolutamente necessario che il rilascio di un semaforo sia effettuato dallo stesso thread che invoca la wait sul semaforo anzi... il contatore di un semaforo è spesso utilizzato per rappresentare il numero di risorse di un certo tipo disponibili (ad esempio messaggi); 37

38 il produttore rilascia il semaforo (aumentando il valore del contatore) quando è disponibile una nuova risorsa; il consumatore attende (invocando la wait) che il valore del contatore sia non nullo per acquisire la nuova risorsa e quindi diminuire il valore del contatore; come si può sfruttare un semaforo per evitare di creare thread nello stato suspended? Una seria limitazione dei semafori è l impossibilità di effettuare un operazione di wait multipla in maniera atomica. 38

39 Eventi L ultimo oggetto che permette la sincronizzazione a livello kernel sono gli eventi. Come il nome suggerisce, gli eventi sono utilizzati per segnalare ad altri thread che è avvenuto, appunto, un evento. Una importante caratteristica degli eventi è che più di un thread può essere risvegliato da una wait quando viene segnalato un singolo evento. Gli eventi sono classificati come manual-reset: indica la capacità di segnalare simultaneamente più thread che attendono l evento e può essere resettato auto-reset: segnala un singolo thread the attende l evento e 39

40 l evento è resettato automaticamente. Per creare un evento: HANDLE CreateEvent{ LP_SECURITY_ATTRIBUTES lpsa, BOOL fmanualreset, BOOL finitialstate, LPTCSTR lpszeventname); se fmanualreset è uguale a TRUE l evento è di tipo manual-reset. finitialstate indica se l evento è nello stato segnalato all atto della creazione. Per accedere un evento, eventualmente da un altro processo, si utilizza la OpenEvent Le seguenti tre funzioni: BOOL SetEvent(HANDLE hevent); BOOL ResetEvent(HANDLE hevent); 40

41 BOOL PulseEvent(HANDLE hevent); sono usate per controllare gli eventi. L attesa di un evento, come negli altri casi, è richiesta tramite la WaitForSingleObject. Un thread segnala l evento con la SetEvent. se l evento è di tipo auto-reset, un singolo thread viene risvegliato e l evento ritorna automaticamente (da cui il nome) allo stato di non-segnalato. Se nessun thread è in attesa, l evento rimane nello stato segnalato fino a quando un thread invoca una wait che, in questo caso, ritorna immediatamente. notare come questo è lo stesso comportamento che si avrebbe utilizzando un semaforo con un max count uguale a 1. se l evento è di tipo manual-reset, rimane segnalato fino a quando un thread non invoca la ResetEvent per quell evento. 41

42 In questo intervallo di tempo, l evento rimane nello stato segnalato. PulseEvent rilascia tutti i thread attualmente in attesa su un evento di tipo manual-reset ma l evento ritorna immediatamente allo stato non-segnalato. Attenzione all utilizzo di WaitForMultipleObjects per attendere che un insieme di eventi sia segnalato. Alcuni eventi potrebbero essere resettati prima che altri vengano segnalati mentre la funzione ritorna solo quando tutti gli eventi sono simultaneamente nello stato segnalato. La combinazione di auto- e manual-reset con l utilizzo di SetEvent o PulseEvent mette a disposizione diversi modi di usare gli eventi. un auto-reset è come una porta con una molla che si chiude automaticamente; in un manual-reset la porta, una volta aperta, rimane tale; 42

43 PulseEvent apre la porta e la molla immediatamente; esempio: eventpc.c in chaptr09. Table 1: Tabella Riassuntiva sugli eventi Evento Auto-Reset Evento Manual Reset Set Event Un solo thread viene Tutti i thread in attesa rilasciato. Se nessun sono rilasciati. L evento thread è in attesa, rimane segnalato fino il primo thread che entra a quando non viene in attesa viene rilasciato resettato da un thread. automaticamente. Pulse Event Esattamente un thread Tutti i thread in attesa sono viene rilasciato ma solo rilasciati e l evento viene se è in attesa. resettato. Attenzione la Pulse Event è considerata ora unreliable! 43

44 Altre primitive di sincronizzazione in Win32 Oltre alle funzioni già viste per l incremento atomico, sono utili le seguenti primitive: LONG InterlockedExchange(LPLONG Target, LONG Value); ritorna il valore attuale di *Target e lo pone uguale a Value LONG InterlockedExchangeAdd(PLONG Addend, LONG Increment); aggiunge Increment a *Added ritornando il valore originale di *Addend PVOID InterlockedCompareExchange(PVOID *Destination, PVOID Exchange, PVOID Comparand} esegue in maniera atomica il seguente frammento di codice: Temp=*Destination; if (*Destination == Comparand) *Destination = Exchange; return Temp; questa primitiva permette di implementare il controllo su una critical section. 44

45 Table 2: Tabella delle primitive di sincronizzazione in Win32 CS MUTEX SEMAFORI EVENTI Dotato di nome e No Si Si Si Attributi sicurezza Accesso da processi No Si Si Si Sincronizzazione Enter Wait Wait Wait Rilascio Leave Release Qualsiasi thread Set/Pulse può rilasciarlo Controllo Un thread può Un thread può N/A N/A entrare più invocare wait volte più volte Rilascio Un thread in Un thread può Più thread Uno o più attesa può ottenere il possono thread entrare controllo procedere procedono 45

46 Condition variable in Win32 (1) Utilizzando una combinazione delle primitive mutex ed event vogliamo implementare un meccanismo equivalente alla condition variable delle pthreads. Consideriamo come esempio il caso produttore/consumatore ma la tecnica si può applicare in molti problemi di sincronizzazione: 1. il produttore prende il controllo del mutex, cambia lo stato, segnala l evento (PulseEvent), rilascia il controllo del mutex; notare come l evento deve essere segnalato mentre ancora si controlla il mutex; 2. il consumatore testa il predicato della CV dopo aver preso il controllo del mutex; 46

47 3. se il predicato non è soddisfatto, il consumatore rilascia il mutex prima di andare in wait sull evento; 4. la wait sull evento deve avere un timeout nel caso il produttore segnali l evento nell intervallo tra il rilascio del mutex e la wait (il segnale andrebbe perso in questo caso); 5. il consumatore controlla il predicato dopo la wait; se il predicato non è soddisfatto torna al passo 2; 6. il consumatore ha il controllo del mutex quando lascia il loop. esempio (barriera): include/synchobj.h e chaptr10/thbobject.c Le condition variable dei pthread sono in qualche modo paragonabili agli eventi ma sono sempre usate insieme ad un mutex. 47

48 Condition variable in Win32 (2) Un interessante articolo sull implementazione di cv sotto Windows Recentemente (Windows Vista e Windows Server Longhorn) sono state introdotte nella Win32 API delle reali condition variable. Per inizializzare la condition variable VOID WINAPI InitializeConditionVariable( PCONDITION_VARIABLE ConditionVariable); Esistono due primitive per l attesa sulla cv associate rispettivamente ad un slim read-write lock ed ad una critical section. BOOL WINAPI SleepConditionVariableSRW( PCONDITION_VARIABLE ConditionVariable, PSRWLOCK SRWLock, 48

49 DWORD dwmilliseconds, ULONG Flags); BOOL WINAPI SleepConditionVariableCS( PCONDITION_VARIABLE ConditionVariable, PCRITICAL_SECTION CriticalSection, DWORD dwmilliseconds); il thread va in attesa della condition variable e rilascia il lock o la sezione critica con un operazione atomica. Gli slim read-write lock sono anche essi una recente novità ed offrono funzionalità di lock per i thread appartenenti ad uno stesso processo più veloci dei tradizionali mutex. Per segnalare che la condizione è verificata esistono due funzioni: 49

50 VOID WINAPI WakeConditionVariable( PCONDITION_VARIABLE ConditionVariable); VOID WINAPI WakeAllConditionVariable( PCONDITION_VARIABLE ConditionVariable); Risvegliare un thread è come segnalare un evento di tipo auto-reset con la SetEvent, mentre risvegliare tutti i thread è equivalente ad utilizzare una PulseEvent su un evento di tipo manual reset. 50

51 Deadlock static struct { HANDLE guard; struct List; } ListaA, ListB; DWORD AddSharedElement(void *arg) { WaitForSingleObject(ListA.guard,INFINITE); WaitForSingleObject(ListB.guard,INFINITE); /* Add element... */ ReleaseMutex(ListB.guard); ReleaseMutex(ListA.guard); return 0;} DWORD DelSharedElement(void *arg) { WaitForSingleObject(ListB.guard,INFINITE); WaitForSingleObject(ListA.guard,INFINITE); /* Del element... */ ReleaseMutex(ListB.guard); ReleaseMutex(ListA.guard); return 0;} 51