(fork, wait, ...) , Thread (pthread) - lucidi - Dipartimento di Ingegneria ...

Sistemi Operativi 

Corso di Laurea Triennale 

in Ingegneria Informatica 

Esercitazione 6 

• Programmazione concorrente 

• Ripasso processi 

• Thread: 

• Join, mutex, condition 

daniel.cesarini@for.unipi.it 

1

Domande sulle 

lezioni passate

Sommario 

Programmazione concorrente 

Processi 

Operazioni sui processi 

Creazione, comunicazione, ... 

Thread POSIX 

Operazioni sui Thread 

Creazione, terminazione, join 

Sincronizzazione 

Semafori 

Variabili condition 

Aspetti preliminari dei thread POSIX 3

Processi Unix

System call per i processi 

Creazione di processi: fork() 

Terminazione: exit() 

Sospensione in attesa della 

terminazione di figli: wait() 

Sostituzione di codice e dati: exec..() 


Creazione di processi: fork() - 1 

fork() consente a un processo di 

generare un processo figlio: 

Padre e figlio condividono lo stesso codice 

Il figlio eredita una copia dei dati (di utente 

e di kernel) del padre 

padre 

fork( ) 

figlio 


Relazione padre-figlio - fork() 

Concorrenza: padre e figlio procedono in 

parallelo 

Il codice è condiviso 

Lo spazio degli indirizzi è duplicato: 

Ogni variabile del figlio è inizializzata con il valore 

assegnatole dal padre prima della fork() 

La user structure è duplicata: 

Le risorse allocate al padre prima della generazione sono 

condivise col figlio 

Stessa gestione dei segnali per padre e figlio 

Il figlio nasce con lo stesso Program Counter del padre: la 

prima istruzione eseguita è quella che segue 

immediatamente la fork() 


Esempio di fork() ed execl() 

#include 

#include 

#include 

int int main main (int (int argc, char char * argv[]) { 

int int pid, pid, status; 

pid=fork(); 

if if (pid==0) { 

execl("/bin/ls", "ls", "-l", (char *) *) 0); 0); 

printf("exec fallita!\n"); 

exit(1); 

} 

else else if if (pid>0) { 

pid=wait(&status); 

/* /* Gestione dello stato */ */ 

} 

else else printf("fork fallita!\n"); 

} 


Codice nella cartella esempi 

fork1.c 

Called once, returns twice 

fork2.c 

Uso di getpid() e getppid() 

exec1.c 

Uso di execv (path ...) 

fdtest1.c 

Read e Write dagli stessi file 


Codice nella cartella esempi 

die1.c 

Padre termina prima del figlio ( ./die) 


Figlio termina prima del padre ( ./die2 &) 


Signal handler in azione ( ./die3 &) 



thread = filo


Introduzione ai thread POSIX 

operazioni elementari sui thread 


Semafori 

semafori di mutua esclusione 

semafori generali 

utilizzo ed esempi 


generalità 

utilizzo ed esempi 


Thread POSIX: aspetti 

preliminari

Processo vs Thread (2 di 2) 

I thread eseguono su memoria condivisa nell’ambito dello stesso processo, 

quando un thread viene creato condivide il suo spazio di memoria con gli 

altri thread che fanno parte del processo 

Sono anche chiamati lightweight process o processi leggeri perché 

possiedono un contesto più snello rispetto ai processi 


Thread 

Thread 

è l’unità granulare in cui un processo può essere 

suddiviso e che può essere eseguito in parallelo 

ad altri thread 

è parte del processo che viene eseguita in 

maniera concorrente ed indipendente 

internamente al processo stesso 

insieme di istruzioni che vengono eseguite in 

modo indipendente rispetto al main 

Stato di un thread 

stack 

registri 

proprietà di scheduling 

stato dei segnali 

dati privati 


Funzioni delle API per Pthread 

Le API per Pthread distinguono le funzioni in 

3 gruppi: 

Thread management 

funzioni per creare, eliminare, attendere la fine dei 

pthread 

Mutexes: 

funzioni per supportare un tipo di sincronizzazione 

semplice chiamata “mutex” (mutua esclusione). 

funzioni per creare ed eliminare la struttura per la 

mutua esclusione di una risorsa, acquisire e rilasciare 

tale risorsa. 

Condition variables: 

funzioni a supporto di una sincronizzazione più 

complessa, dipendente dal valore di variabili, secondo 

i modi definite dal programmatore. 

funzioni per creare ed eliminare la struttura per la 

sincronizzazione, per attendere e segnalare le 

modifiche delle variabili. 


Utilizzo 

includere l’header della libreria che 

contiene le definizioni dei pthread 

#include 

Per interpretare correttamente i messaggi di 

errore è necessario anche includere l’header 

 

compilare specificando la libreria 

gcc -lpthread 

Libreria pthread (libpthread) lpthread 

Per ulteriori informazioni sulla compilazione fare 

riferimento alla documentazione della 

piattaforma utilizzata man pthread o man 

pthreads 


Convenzione sui nomi delle funzioni 

Gli identificatori della libreria dei Pthread iniziano 

con pthread_ 

pthread_ 

indica la gestione dei thread in generale 

pthread_attr_ 

funzioni per gestire proprietà dei thread 

pthread_mutex_ 

gestione della mutua esclusione 

pthread_mutexattr_ 

proprietà delle strutture per la mutua esclusione 

pthread_cond_ 

gestione delle variabili di condizione 

pthread_condattr_ 

proprietà delle variabili di condizione 

pthread_key_ 

dati speciali dei thread 


Gestione dei thread

Tipi definiti nella libreria pthread 

All’interno di un programma un thread è 

rappresentato da un identificatore 

tipo opaco pthread_t 

Attributi di un thread 

tipo opaco pthread_attr_t 

tipo opaco: si definiscono così strutture ed altri oggetti usati da una libreria, la cui 

struttura interna non deve essere vista dal programma chiamante (da cui il 

nome) che li deve utilizzare solo attraverso dalle opportune funzioni di gestione. 


Identificatore del thread 

Processo: process id (pid) 

pid_t 

Thread: thread id (tid) pthread_t 

pthread_t pthread_self( void ) 

restituisce il tid del thread chiamante 


Confronto tra thread 

int int pthread_equal( pthread_t t1, t1, pthread_t t2 t2 ) 

confronta i due identificatori di thread. 

1 se i due identificatori sono uguali 


Creazione di un thread (1 di 2) 

int int pthread_create( pthread_t *thread, 

const pthread_attr_t *attr, 

void *(*start_routine)(void *), *), 

void *arg ) 

crea una thread e lo rende eseguibile, cioè lo 

mette a disposizione dello scheduler per 

farlo partire (). 

Non è prevedibile 

il momento dell'attivazione 

del thread 


Creazione di un thread (2 di 2) 

 

 

pthread_t *thread 

puntatore ad un identificatore di thread in cui verrà scritto 

l’identificatore univoco del thread creato (se creato con 

successo) 

const pthread_attr_t *attr 

attributi del processo da creare: può indicare le caratteristiche 

del thread riguardo alle operazioni di join o allo scheduling 

se NULL usa valori di default 

void *(*start_routine)(void *) 

è il nome (indirizzo) della funzione da eseguire alla creazione del 

thread 

 

 

void *arg 

puntatore che viene passato come argomento a 

start_routine. 

Valore di ritorno 

0 in assenza di errore 

diverso da zero altrimenti 

attributi errati 

mancanza di risorse 


Terminazione di un thread 

void pthread_exit( void *value_ptr ) 

 

 

 

 

Termina l’esecuzione del thread da cui viene chiamata 

Il sistema libera le risorse allocate al thread. 

Se il main termina prima che i thread da lui creati siano 

terminati e non chiama la funzione pthread_exit, allora 

tutti i thread sono terminati. Se invece il main chiama 

pthread_exit allora i thread possono continuare a vivere 

fino alla loro terminazione. 

void *value_ptr 

valore di ritorno del thread consultabile da altri thread 

attraverso la funzione pthread_join 


Esempio 1: creazione e terminazione 

(1 di 2) 

/* /* Include Include */ */ 

#include #include 

 


 


 

#define #define NUM_THREADS NUM_THREADS 5 

/* /* Corpo Corpo del del thread thread */ */ 

void void *PrintHello(void *PrintHello(void *num) *num) { 

printf("\n%d: printf("\n%d: Hello Hello World!\n", World!\n", num); num); 

pthread_exit(NULL); 


}} 

Continua 


Esempio 1: creazione e terminazione 


/* /* Programma Programma */ */ 

int int main main (int (int argc, argc, char char *argv[]) *argv[]) 

{ 

pthread_t pthread_t threads[NUM_THREADS]; 

threads[NUM_THREADS]; 

int int rc, rc, t; t; 

for(t=0; for(t=0; t

Passaggio parametri (1 di 3) 

La pthread_create prevede un puntatore per il 

passaggio dei parametri al thread nel momento 

in cui comincia l’esecuzione. 

Si ponga attenzione nel caso il thread debba 

modificare i parametri, oppure il chiamante 

debba modificare i parametri, potrebbero 

insorgere problemi, meglio dedicare una 

struttura dati ad hoc, per il passaggio. 



Per riferimento con un cast a void* 

Esempio (errato) 

il ciclo modifica il contenuto dell’indirizzo passato 

come parametro 

int 

int 

rc, 

rc, 

t; 

t; 

for(t=0; for(t=0; t


Esempio (corretto) 

struttura dati univoca per ogni thread 

int int *taskids[NUM_THREADS]; 

*taskids[NUM_THREADS]; 

for(t=0; for(t=0; t

Esempio 2 errato: passaggio parametri (1 

di 2) 



 



 

#define 

#define 

NUM_THREADS 

NUM_THREADS 

5 



printf("\n%d: printf("\n%d: Hello Hello World!\n", World!\n", *(int *(int *) *) num); num); 



} 


Esempio 2 errato : passaggio parametri (2 




{ 




} 

for(t=0; for(t=0; t

Esempio 2 : passaggio parametri (1 




 



 

#define 

#define 

NUM_THREADS 

NUM_THREADS 

5 



printf("\n%d: printf("\n%d: Hello Hello World!\n", World!\n", *(int *(int *) *) num); num); 



} 


Esempio 2 : passaggio parametri (2 




{ 




int int *taskids[NUM_THREADS]; 

*taskids[NUM_THREADS]; 

for(t=0; for(t=0; t

Esercizi 

(parte uno)

Esercizio 1 

pthreads-1a-simple.c 

analizzare l'output 

cambiare pthreads_exit(NULL) in 

return(0) 

cosa succede? 

aggiungere il passaggio di un parametro ai 

thread passando a tutti lo stesso valore 

pthreads-1b-simple.c 

cosa cambia rispetto al precedente? 

pthreads-1c-simple.c 

soluzione dell'esercizio precedente 


pthreads-1a-simple.c 

#include 

#include 

#include 

#include 

#define NUM_THREADS 3 

void *thread_function(void* arg){ 

printf("[Thread] Waiting for termination...\n"); 

sleep(5); 

printf("[Thread] ...thread finished!\n"); 


} 

int main(void){ 

pthread_t tids[NUM_THREADS]; 

int i, rc; 

printf("[Main] Starting...\n"); 

for (i=0; i

pthreads-1b-simple.c (1 di 

2) 

#include 

#include 

#include 

#include 


void *thread_function(void* arg){ 

printf("[Thread] Waiting for termination...\n"); 

sleep(5); 

printf("[Thread] ...thread finished!\n"); 


} 

Continua 


pthreads-1b-simple.c (2 di 

2) 

int main(void){ 


int i, rc; 


for (i=0; i

Esercizio 2 

pthreads-2a-args.c 


modificare in modo da ottenere un 

funzionamento corretto 

pthreads-2b-args.c 



pthreads-2a-args.c 

#include 

#include 

#include 

#include 


void *thread_function(void* arg) 

{ 

int i = *(int*)arg; 

printf("[Thread %d] Waiting for termination...\n",i); 

sleep(5); 

printf("[Thread %d] ...thread finished!\n",i); 


} 

int main(void) 

{ 


int i, rc; 


for (i=0; i


(semplice)

Join tra thread 

Forma elementare di sincronizzazione 

il thread che effettua il join si blocca 

finché uno specifico thread non termina 

il thread che effettua il join può ottenere lo 

stato del thread che termina 

Attributo detachstate di un thread 

specifica se si può invocare o no la 

funzione join su un certo thread 

un thread è joinable per default 


Operazione di join 

int int pthread_join( pthread_t *thread, void **value ) 

 

 

 

pthread_t *thread 

identificatore del thread di cui attendere la 

terminazione 

void **value 

valore restituito dal thread che termina 


0 in caso di successo 

EINVAL se il thread da attendere non è joinable 

ERSCH se non è stato trovato nessun thread 

corrispondente all’identificatore specificato 


Impostazione attributo di join 


int int pthread_attr_init( pthread_attr_t *attr ) 

Inizializza gli attributi del pthread 

int int pthread_attr_destroy ( pthread_attr_t *attr) 

Dealloca il pthread 




Un thread può essere: 

Joinable: i thread non sono rilasciati 

automaticamente ma rimangono come zombie 

finchè altri thread non effettuano delle join 

Detached: i thread detached sono rilasciati 

automaticamente e non possono essere oggetto 

di join da parte di altri thread. 

int int pthread_attr_setdetachstate( pthread_attr_t *attr, 

int int detachstate ) 

 

Detach può essere: 

PTHREAD_CREATE_DETACHED 

PTHREAD_CREATE_JOINABLE. 




/* /* Attributo Attributo */ */ 

pthread_attr_t pthread_attr_t attr; attr; 

/* /* Inizializzazione Inizializzazione esplicita esplicita dello dello stato stato joinable joinable */ */ 

pthread_attr_init(&attr); 


pthread_attr_setdetachstate(&attr, 


PTHREAD_CREATE_JOINABLE); 


... ... 

pthread_attr_destroy(&attr); 





int int main main (int (int argc, argc, char char *argv[]) *argv[]) { 

pthread_t pthread_t thread[NUM_THREADS]; 

thread[NUM_THREADS]; 

... ... 



for(t=0; for(t=0; t

Esempio 3: thread join (1 di 3) 



 


#include 

#include 

 

 

#define #define NUM_THREADS NUM_THREADS 5 


printf("\n%d: printf("\n%d: Hello Hello World!\n", World!\n", num); num); 



} 

Continua 






void void *status; *status; 



/* /* Inizializzazione Inizializzazione esplicita esplicita dello dello stato stato joinable joinable */ */ 







for(t=0; for(t=0; t


for(t=0; for(t=0; t

Sincronizzazione tra thread 

Attraverso variabili globali 

condivise tra thread 

meccanismi di protezione 

Compito del programmatore 

corretto utilizzo delle funzioni di 

sincronizzazione 

Meccanismi forniti dalla libreria 

semafori di mutua esclusione 

variabili condition 

semafori generali 


Semafori

Cosa sono i semafori? 

I semafori sono primitive fornite dal 

sistema operativo per permettere la 

sincronizzazione tra processi e/o 

thread. 


Operazioni sui semafori 

In genere sono tre le operazioni che vengono 

eseguite da un processo su 

un semaforo: 

Create: creazione di un semaforo. 

Wait: attesa su di un semaforo dove si verifica il 

valore del semaforo 

while(sem_value

Semafori di mutua esclusione

Cosa sono i mutex? (1 di 2) 

Una variabile mutex è una variabile 

che serve per la protezione delle 

sezioni critiche: 

variabili condivise modificate da più 

thread 

solo un thread alla volta può accedere ad 

una risorsa protetta da un mutex 

Il mutex è un semaforo binario cioè il 

valore può essere 0 (occupato) oppure 

1 (libero) 


Cosa sono i mutex? (2 di 2) 

Pensiamo ai mutex come a delle 

serrature: 

il primo thread che ha accesso alla coda 

dei lavori lascia fuori gli altri thread fino a 

che non ha portato a termine il suo 

compito. 

I threads piazzano un mutex nelle 

sezioni di codice nelle quali vengono 

condivisi i dati. 


Garantire la Mutua Esclusione (1 


Due thread devono decrementare il valore di 

una variabile globale data se questa è 

maggiore di zero 

data = 1 

THREAD1 

THREAD2 

if(data>0) 

if(data>0) 

data --; data --; 


Garantire la Mutua Esclusione (2 


A seconda del tempo di esecuzione dei due thread, la 

variabile data assume valori diversi. 

Data THREAD1 THREAD2 

1 if(data>0) 

1 data --; 

0 if(data>0) 

0 data --; 

0 = valore finale di data 

-------------------------------------------------------- 

1 if(data>0) 

1 if(data>0) 

1 data --; 

0 data --; 

-1 = valore finale di data 


Uso dei mutex 

Creare e inizializzare una variabile mutex 

Più thread tentano di accedere alla risorsa 

invocando l’operazione di lock 

Un solo thread riesce ad acquisire il mutex 

mentre gli altri si bloccano 

Il thread che ha acquisito il mutex manipola 

la risorsa 

Lo stesso thread la rilascia 

invocando la unlock 

Un altro thread acquisisce il mutex e così via 

Distruzione della variabile mutex 


Creazione mutex 

 

Per creare un mutex è necessario usare 

una variabile di tipo pthread_mutex_t 

contenuta nella libreria pthread 

pthread_mutex_t è una struttura che 

contiene: 

Nome del mutex 

Proprietario 

Contatore 

Struttura associata al mutex 

 

 

La coda dei processi sospesi in attesa che mutex sia 

libero. 

… e simili 


Inizializzazione mutex 

statica 

contestuale alla dichiarazione 

dinamica 

attraverso 

pthread_mutex_t mutex; 

pthread_mutex_init (&mutex, NULL); 


Inizializzazione statica 

 

Per il tipo di dato pthread_mutex_t, è definita la 

macro di inizializzazione 

PTHREAD_MUTEX_INITIALIZER 

 

Il mutex è un tipo definito "ad hoc" per gestire la 

mutua esclusione quindi il valore iniziale può 

essergli assegnato anche in modo statico mediante 

questa macro. 

/* /* Variabili globali */ */ 

pthread_mutex_t amutex = PTHREAD_MUTEX_INITIALIZER; 


Inizializzazione dinamica 

pthread_mutex_t mutex; 

int int pthread_mutex_init( pthread_mutex_t *mutex, const 

pthread_mutexattr_t *mattr ) 

 

 

 

pthread_mutex_t *mutex 

puntatore al mutex da inizializzare 

pthread_mutexattr_t *mattr 

attributi del mutex da inizializzare 

se NULL usa valori default 


sempre il valore 0 


Interfacce 

Su mutex sono possibili solo due 

operazioni: locking e unlocking 

(equivalenti a wait e signal sui 

semafori) 


Interfaccia: Lock 

Ogni thread, prima di accedere ai dati 

condivisi, deve effettuare la lock su una 

stessa variabile mutex. 

Blocca l’accesso da parte di altri thread. 

Se più thread eseguono l’operazione di lock 

su una stessa variabile mutex, solo uno dei 

thread termina la lock e prosegue 

l’esecuzione, gli altri rimangono bloccati 

nella lock. In tal modo, il processo che 

continua l’esecuzione può accedere ai dati 

(protetti mediante la mutex). 


Operazioni: lock e trylock 

lock 

bloccante (standard) 

trylock 

non bloccante (utile per evitare deadlock) 

è come la lock() ma se si accorge che il mutex è 

già in possesso di un altro thread (e quindi si 

rimarrebbe bloccati) restituisce immediatamente 

il controllo al chiamante con risultato EBUSY 

Una situazione di deadlock si verifica quando uno o più thread sono 

bloccati aspettando un evento che non si verificherà mai. 


lock 

int int pthread_mutex_lock( pthread_mutex_t *mutex ) 


puntatore al mutex da bloccare 



diverso da 0 altrimenti 


trylock 

int int pthread_mutex_trylock( pthread_mutex_t *mutex ) 

 

 


puntatore al mutex da bloccare 


0 in caso di successo e si ottenga la proprietà 

della mutex 

EBUSY se il mutex è occupato 


Interfaccia: Unlock 

Libera la variabile mutex. 

Un altro thread che ha 

precedentemente eseguito la lock 

della mutex potrà allora terminare la 

lock ed accedere a sua volta ai dati. 


unlock 

int int pthread_mutex_unlock( pthread_mutex_t *mutex ) 


puntatore al mutex da sbloccare 




destroy 

int int pthread_mutex_destroy( pthread_mutex_t *mutex ) 

Elimina il mutex 


puntatore al mutex da distruggere 



EBUSY se il mutex è occupato 


Esempio 4: uso dei mutex (1 di 2) 


 

int int a=1, a=1, b=1; b=1; 

pthread_mutex_t pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; 

PTHREAD_MUTEX_INITIALIZER; 

void* void* thread1(void thread1(void *arg) *arg) { 

pthread_mutex_lock(&m); 


printf(“Primo printf(“Primo thread thread (parametro: (parametro: %d)\n", %d)\n", *(int*)arg); 

*(int*)arg); 

a++; a++; b++; b++; 

pthread_mutex_unlock(&m); 


} 

} 




printf(“Secondo 


thread 

thread 

(parametro: 

(parametro: 

%d)\n", 

%d)\n", 

*(int*)arg); 

*(int*)arg); 

b=b*2; b=b*2; a=a*2; a=a*2; 



} Continua 


Esempio 4: uso dei mutex (2 di 2) 

main() main() { 

pthread_t pthread_t threadid1, threadid1, threadid2; 

threadid2; 

int int i = 1, 1, j=2; j=2; 

pthread_create(&threadid1, pthread_create(&threadid1, NULL, NULL, thread1, thread1, (void (void *)&i); *)&i); 

pthread_create(&threadid2, pthread_create(&threadid2, NULL, NULL, thread2, thread2, (void (void *)&j); *)&j); 

pthread_join(threadid1, pthread_join(threadid1, NULL); NULL); 


printf("Valori 

printf("Valori 

finali: 

finali: 

a=%d 

a=%d 

b=%d\n", 

b=%d\n", 

a, 

a, 

b); 

b); 

} 

Tratto con modifiche da: 

http://www.univ.trieste.it/~mumolo/posix2.p 

df 


Esempio 5: inizializzazione dinamica 



 

int int a=1, a=1, b=1; b=1; 

pthread_mutex_t pthread_mutex_t m; m; 




printf(“Primo printf(“Primo thread thread (parametro: (parametro: %d)\n", %d)\n", *(int*)arg); 

*(int*)arg); 

a++; a++; b++; b++; 



} 

} 






thread 

thread 

(parametro: 

(parametro: 

%d)\n", 

%d)\n", 

*(int*)arg); 

*(int*)arg); 

b=b*2; b=b*2; a=a*2; a=a*2; 



} Continua 


Esempio 5: inizializzazione dinamica 



pthread_t pthread_t threadid1, threadid1, threadid2; 

threadid2; 

int int i = 1, 1, j=2; j=2; 

pthread_mutex_init(&m, pthread_mutex_init(&m, NULL); NULL); 

pthread_create(&threadid1, pthread_create(&threadid1, NULL, NULL, thread1, thread1, (void (void *)&i); *)&i); 

pthread_create(&threadid2, 

pthread_create(&threadid2, 

NULL, 

NULL, 

thread2, 

thread2, 

(void 

(void 

*)&j); 

*)&j); 



printf("Valori printf("Valori finali: finali: a=%d a=%d b=%d\n", b=%d\n", a, a, b); b); 

pthread_mutex_destroy(&m); 

pthread_mutex_destroy(&m); 

} 


Esempio 6 (1 di 3) 

/* /* esempio utilizzo dei dei Mutex */ */ 

#include 

#include 

pthread_mutex_t mymutex; 

void *body(void *arg){ 

int int i,j; 

for for (j=0; j


int int main(){ 

pthread_t t1,t2,t3; 

pthread_attr_t myattr; 

int int err; 

pthread_mutexattr_t mymutexattr; 

pthread_mutexattr_init(&mymutexattr); 

pthread_mutex_init(&mymutex, &mymutexattr); 

pthread_mutexattr_destroy(&mymutexattr); 

pthread_attr_init(&myattr); 

… 

Continua 

 



err err = pthread_create(&t1, &myattr, body, body, (void (void *)"."); 

err err = pthread_create(&t2, &myattr, body, body, (void (void *)"#"); 

err err = pthread_create(&t3, &myattr, body, body, (void (void *)"o"); 

pthread_attr_destroy(&myattr); 

} 

pthread_join(t1, NULL); 



printf("\n"); 

return 0; 0; 


Esercizio 3 

pthreads-3a-mutex.c 


modificare in modo da ottenere un 

funzionamento corretto 

pthreads-3b-mutex.c 



pthreads-3a-mutex.c 

#include 

#include 


int shared = 0; 

void *thread_main(void* arg){ 

int i,k; 

for (i=0; i

Variabili condition

Condition vs Semafori 

Le variabili condition sono molto diverse dai 

semafori di sincronizzazione, anche se 

semanticamente fanno la stessa cosa 

Le primitive delle condition si preoccupano di 

rilasciare la mutua esclusione prima di 

bloccarsi e ed riacquisirla dopo essere state 

sbloccate 

I semafori generali, invece, prescindono dalla 

presenza di altri meccanismi 


Cosa sono le variabili condition 

Strumento di sincronizzazione: consente 

la sospensione dei thread in attesa che sia 

soddisfatta una condizione logica. 

Una condition variable è utilizzata per 

sospendere l'esecuzione di un thread in 

attesa che si verifichi un certo evento. 

Ad ogni condition viene associata una coda 

per la sospensione dei thread. 

La variabile condizione non ha uno stato, 

rappresenta solo una coda di thread. 



Attraverso le variabili condition è 

possibile implementare condizioni più 

complesse che i thread devono 

soddisfare per essere eseguiti. 

Linux garantisce che i thread bloccati 

su una condizione vengano sbloccati 

quando essa cambia. 


Mutua esclusione 

Una variabile condizione non fornisce 

la mutua esclusione. 

C'è bisogno di un mutex per poter 

sincronizzare l'accesso ai dati. 



Una variabile condition è sempre associata 

ad un mutex 

un thread ottiene il mutex e testa il predicato 

se il predicato è verificato allora il thread 

esegue le sue operazioni e rilascia il mutex 

se il predicato non è verificato, in modo 

atomico 

il mutex viene rilasciato (implicitamente) 

il thread si blocca sulla variabile condition 

un thread bloccato riacquisisce il mutex nel 

momento in cui viene svegliato da un altro 

thread 


Creazione condition 

Oggetti di sincronizzazione su cui un 

processo si può bloccare in attesa 

associate ad una condizione logica 

arbitraria 

generalizzazione dei semafori 

nuovo tipo pthread_cond_t 

attributi variabili condizione di tipo 

pthread_condattr_t 


Inizializzazione statica 

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

• Per il tipo di dato pthread_cond_t, è definita 

la macro di inizializzazione 

PTHREAD_COND_INITIALIZER 


Inizializzazione dinamica 

int int pthread_cond_init( pthread_cond_t *cond, 

pthread_condattr_t *cond_attr ) 

 

 

pthread_cond_t *cond 

puntatore ad un’istanza di condition che 

rappresenta la condizione di sincronizzazione 

pthread_condattr_t *cond_attr 

punta a una struttura che contiene gli attributi 

della condizione 

se NULL usa valori di default 


Distruzione variabili condition 

int int pthread_cond_destroy( pthread_cond_t *cond ) 

Dealloca tutte le risorse allocate per gestire la 

variabile condizione specificata 

Non devono esistere thread in attesa della 

condizione 


puntatore ad un’istanza di condition da distruggere 


0 in caso di successo oppure un codice d’errore ≠0 


Interfacce 

Operazioni fondamentali: 

wait (sospensione) 

signal ( risveglio) 


Interfaccia wait 

La wait serve per sincronizzarsi con una certa 

condizione all'interno di un blocco di dati condivisi e 

protetti da un mutex 

La presenza del mutex fra i parametri garantisce 

che, al momento del bloccaggio, esso venga 

liberato, eliminando a monte possibili errori di 

programmazione che potrebbero condurre a 

condizioni di deadlock. 

Se la wait ritorna in modo regolare, è garantito che 

la mutua esclusione, sul semaforo mutex passatole, 

sia stata nuovamente acquisita. 


wait 

int int pthread_cond_wait( pthread_cond_t *cond, 

pthread_mutex_t *mutex ) 

 

 

 


puntatore ad un’istanza di condition che 

rappresenta la condizione di sincronizzazione 

puntatore all’oggetto condizione su cui bloccarsi 


l'indirizzo di un semaforo di mutua esclusione 

necessario alla corretta consistenza dei dati 


sempre 0 


Interfaccia signal 

La signal non si preoccupa di liberare la 

mutua esclusione, infatti, fra i suoi parametri 

non c'è il mutex 

Il mutex deve essere rilasciato 

esplicitamente, altrimenti si potrebbe 

produrre una condizione di deadlock. 

Due varianti 

Standard: sblocca un solo thread bloccato 

Broadcast: sblocca tutti i thread bloccati 


signal 

int int pthread_cond_signal ( pthread_cond_t *cond) 

Se esistono thread sospesi nella coda associata a 

cond, viene risvegliato il primo. 

Se non vi sono thread sospesi sulla condizione, la 

signal non ha effetto. 


puntatore all’oggetto condizione 


sempre 0 


oadcast 

int int pthread_cond_broadcast ( pthread_cond_t *cond ) 

Se esistono thread sospesi nella coda 

associata a cond, vengono svegliati tutti 

altrimenti nessun effetto 


puntatore all’oggetto condizione 


sempre 0 


Valutazione condizione 

Il thread svegliato deve rivalutare la condizione 

l’altro thread potrebbe non aver testato la 

condizione 

la condizione potrebbe essere cambiata nel 

frattempo 

possono verificarsi wakeup “spuri” 

pthread_mutex_lock(&mutex); 

while(!condition_to_hold) 

ptread_cond_wait(&cond, &mutex); 

computation(); 

pthread_mutex_unlock(&mutex); 


Stato della coda 

Non è prevista una funzione per 

verificare lo stato della coda associata 

a una condizione. 


Esempio di utilizzo (1 di 2) 

Risorsa che può essere usata 

contemporaneamente da MAX thread. 

condition PIENO per la sospensione dei thread 

M mutex associato a pieno 

N_int numero di thread che stanno utilizzando la 

risorsa 

#define MAX 100 

/*variabili globali*/ 

int N_in=0 /*numero thread che stanno utilizzando la risorsa*/ 

pthread_cond_t PIENO; 

pthread_ mutex M;/*mutex associato alla cond. PIENO*/ 


Esempio di utilizzo (2 di 2) 

void codice_thread() { 

/*fase di entrata*/ 

pthread_mutex_lock(&M); 

/* controlla la condizione di ingresso*/ 

if(N_in == MAX) 

pthread_cond_wait(&PIENO,&M); 

/*aggiorna lo stato della risorsa */ 

N_in ++; 

pthread_mutex_unlock(&M); 

 

/*fase di uscita*/ 

pthread_mutex_lock(&M); 

/*aggiorna lo stato della risorsa */ 

N_in --; 

pthread_cond_signal(&PIENO); 

pthread_mutex_unlock(&M); 

} 




 


 


 

/* /* mutex mutex */ */ 

pthread_mutex_t pthread_mutex_t condition_mutex condition_mutex = PTHREAD_MUTEX_INITIALIZER; 

PTHREAD_MUTEX_INITIALIZER; 

/* /* condition condition variable*/ 

variable*/ 

pthread_cond_t 

pthread_cond_t 

condition_cond 

condition_cond 

= 

= 

PTHREAD_COND_INITIALIZER; 

PTHREAD_COND_INITIALIZER; 

Continua 

 



void void thread1_func(void thread1_func(void *ptr) *ptr) { 

printf("Avvio printf("Avvio dell’esecuzione dell’esecuzione del del %s.\n",(char %s.\n",(char *)ptr); *)ptr); 

sleep(2); sleep(2); /* /* pausa pausa di di 2 secondi secondi */ */ 

printf("Thread printf("Thread 1 in in procinto procinto di di entrare entrare nella nella sezione sezione critica.\n"); 

critica.\n"); 

pthread_mutex_lock(&condition_mutex); 


printf("Thread printf("Thread 1 nella nella sezione sezione critica.\n"); 

critica.\n"); 

printf("Thread 


1 

1 

si 

si 

sospende 

sospende 

sulla 

sulla 

condition 


variable.\n"); 


pthread_cond_wait(&condition_cond, pthread_cond_wait(&condition_cond, &condition_mutex); 

&condition_mutex); 

printf("Thread printf("Thread 1 riprende riprende l’esecuzione.\n"); 

l’esecuzione.\n"); 

printf("Thread printf("Thread 1 in in procinto procinto di di uscire uscire dalla dalla sezione sezione critica.\n"); 

critica.\n"); 

pthread_mutex_unlock(&condition_mutex); 


printf("Thread printf("Thread 1 in in procinto procinto di di terminare.\n"); 

terminare.\n"); 

} 

} 

Continua 

 



void void thread2_func(void thread2_func(void *ptr) *ptr) { 

printf("Avvio printf("Avvio dell’esecuzione dell’esecuzione del del %s.\n",(char %s.\n",(char *)ptr); *)ptr); 

sleep(5); sleep(5); /* /* pausa pausa di di 5 secondi secondi */ */ 

printf("Thread printf("Thread 2 in in procinto procinto di di entrare entrare nella nella sezione sezione critica.\n"); 

critica.\n"); 



printf("Thread printf("Thread 2 nella nella sezione sezione critica.\n"); 

critica.\n"); 



2 

2 

segnala 

segnala 

l’evento 

l’evento 

della 

della 





pthread_cond_signal(&condition_cond); 

pthread_cond_signal(&condition_cond); 

printf("Thread printf("Thread 2 in in procinto procinto di di uscire uscire dalla dalla sezione sezione critica.\n"); 

critica.\n"); 



} 

printf("Thread printf("Thread 2 in in procinto procinto di di terminare.\n"); 

terminare.\n"); 

Continua 

 




pthread_t pthread_t thread1,thread2; 

thread1,thread2; 

char char *msg1="Thread *msg1="Thread 1"; 1"; 

char char *msg2="Thread *msg2="Thread 2"; 2"; 

if(pthread_create(&thread1,NULL,(void if(pthread_create(&thread1,NULL,(void *)&thread1_func,(void *)&thread1_func,(void *)msg1)!=0){ 

*)msg1)!=0){ 

perror("Errore perror("Errore nella nella creazione creazione del del primo primo thread.\n"); 

thread.\n"); 

exit(1); exit(1); 

} 

} 

if(pthread_create(&thread2,NULL,(void if(pthread_create(&thread2,NULL,(void *)&thread2_func,(void *)&thread2_func,(void *)msg2)!=0){ 

*)msg2)!=0){ 

perror("Errore perror("Errore nella nella creazione creazione del del secondo secondo thread.\n"); 

thread.\n"); 


} 

pthread_join(thread1,NULL); 





} 


Esempio 9: incremento contatore 

3) 

(1 di 

void void *inc_count(void *inc_count(void *idp) *idp) { 

int int j,i; j,i; double double result=0.0; result=0.0; int int *my_id *my_id = idp; idp; 

for for (i=0; (i=0; i


3) 


void void *watch_count(void *watch_count(void *idp) *idp) { 

int int *my_id *my_id = idp; idp; 

printf("Starting printf("Starting watch_count(): watch_count(): thread thread %d\n", %d\n", *my_id); *my_id); 

pthread_mutex_lock(&count_mutex); pthread_mutex_lock(&count_mutex); /*Lock /*Lock mutex mutex and and wait wait for for signal. signal. */ */ 

while while (count


3) 



int int i, i, res; res; 

pthread_t pthread_t threads[3]; 

threads[3]; 


/* /* Initialize Initialize mutex mutex and and condition condition variable variable objects objects */ */ 

pthread_mutex_init(&count_mutex, pthread_mutex_init(&count_mutex, NULL); NULL); 

pthread_cond_init pthread_cond_init (&count_threshold_cv, (&count_threshold_cv, NULL); NULL); 

/* 

/* 

Create 

Create 

threads 

threads 

and 

and 



for 

for 

all 

all 

threads 

threads 

to 

to 

complete 

complete 

*/ 

*/ 

… 

/* /* Clean Clean up up and and exit exit */ */ 



pthread_mutex_destroy(&count_mutex); 

pthread_mutex_destroy(&count_mutex); 

pthread_cond_destroy(&count_threshold_cv); 

pthread_cond_destroy(&count_threshold_cv); 



} 



#include 

#include 

 

 


 


 


 


 


 

/* /* Numero Numero di di cicli cicli di di lettura/scrittura lettura/scrittura che che vengono vengono fatti fatti dai dai thread thread */ */ 

#define #define CICLI CICLI 1 

/* /* Lunghezza Lunghezza del del buffer buffer */ */ 

#define #define LUN LUN 20 20 

/* /* Numero Numero di di cicli cicli di di attesa attesa a vuoto vuoto di di uno uno scrittore scrittore */ */ 

#define #define DELAY_WRITER DELAY_WRITER 200000 200000 

/* /* Numero Numero di di cicli cicli di di attesa attesa a vuoto vuoto di di uno uno scrittore scrittore */ */ 

#define #define DELAY_READER DELAY_READER 2000000 2000000 



/* 

/* 

Memoria 

Memoria 

Condivisa 

Condivisa 

fra 

fra 

i 

i 

thread 

thread 

... 

... 

*/ 

*/ 

struct struct { 

/* /* Semaforo Semaforo di di mutua mutua esclusione esclusione */ */ 

pthread_mutex_t pthread_mutex_t mutex; mutex; 

/* /* Variabile Variabile condition condition per per il il lettore lettore */ */ 

pthread_cond_t pthread_cond_t lettore; lettore; 

/* /* Variabile Variabile condition condition per per gli gli scrittori scrittori */ */ 

pthread_cond_t pthread_cond_t scrittori; 

scrittori; 

/* /* Buffer Buffer */ */ 

char char scritta[LUN+1]; 

scritta[LUN+1]; 

/* /* Variabili Variabili per per la la gestione gestione del del buffer buffer */ */ 

int int primo, primo, ultimo, ultimo, elementi; 

elementi; 

/* /* Numero Numero di di lettori lettori e scrittori scrittori bloccati bloccati */ */ 

int int blockscri, blockscri, blocklet; 

blocklet; 

} shared shared = {PTHREAD_MUTEX_INITIALIZER, 

{PTHREAD_MUTEX_INITIALIZER, 

PTHREAD_COND_INITIALIZER, 

PTHREAD_COND_INITIALIZER, 

PTHREAD_COND_INITIALIZER}; 

PTHREAD_COND_INITIALIZER}; 



int 

int 

main(void){ 

main(void){ 

pthread_t pthread_t s1TID, s1TID, s2TID, s2TID, lTID; lTID; 

int int res, res, i; i; 

/* /* Inizializzo Inizializzo la la stringa stringa scritta scritta */ */ 

for(i=0; for(i=0; i


res 

res 

= 

= 

pthread_create(&lTID, 

pthread_create(&lTID, 

NULL, 

NULL, 

lettore, 

lettore, 

NULL); 

NULL); 

if if (res (res != != 0) 0) printf("Errore printf("Errore nella nella creazione creazione del del primo primo thread\n"); 

thread\n"); 

res res = pthread_create(&s1TID, pthread_create(&s1TID, NULL, NULL, scrittore1, scrittore1, NULL); NULL); 

if if (res (res != != 0) 0) { 

printf("Errore printf("Errore nella nella creazione creazione del del secondo secondo thread\n"); 

thread\n"); 

pthread_kill(s1TID, pthread_kill(s1TID, SIGKILL);exit(-1); 

SIGKILL);exit(-1); 

} 

res res = pthread_create(&s2TID, pthread_create(&s2TID, NULL, NULL, scrittore2, scrittore2, NULL); NULL); 

if if (res (res != != 0) 0) { 

printf("Errore printf("Errore nella nella creazione creazione del del terzo terzo thread\n"); 

thread\n"); 

pthread_kill(lTID, pthread_kill(lTID, SIGKILL);pthread_kill(s1TID, SIGKILL);pthread_kill(s1TID, SIGKILL); 

SIGKILL); 

return return -1; -1; 

} 

/* /* Aspetto Aspetto che che i tre tre thread thread finiscano finiscano ... ... */ */ 

pthread_join(s1TID, pthread_join(s1TID, NULL);pthread_join(s2TID, NULL);pthread_join(s2TID, NULL); NULL); 

pthread_join(lTID, 

pthread_join(lTID, 

NULL); 

NULL); 

printf("E' printf("E' finito finito l'esperimento l'esperimento ....\n"); 

....\n"); 

return return (0); (0); 

} 



void *scrittore1(void *in){ 

void *scrittore1(void *in){ 

int 

int 

i, 

i, 

j, 

j, 

k; 

k; 

for 

for 

(i=0; 

(i=0; 

i


void *lettore(void *in){ 

void *lettore(void *in){ 

int 

int 

i, 

i, 

k, 

k, 

j; 

j; 

char 

char 

local[LUN+1]; 

local[LUN+1]; 

local[LUN] 

local[LUN] 

= 

= 

0; 

0; 

for 

for 

(i=0; 

(i=0; 

i

Esercizio 4 

pthreads-4a-barrier.c 

modificare in modo da ottenere la 

sincronizzazione desiderata 

tutti i thread si bloccano alla barriera 

aspettando l'arrivo di tutti gli altri 

tutti i thread proseguono l'esecuzione 

quando l'ultimo ha raggiunto la barriera 

suggerimento: usare una variabile 


pthreads-4b-barrier.c 





#include 

#include 

#include 

#include 

#include 


/* Some variables are needed here... */ 

int n_threads; /* number of worker threads */ 

/* Complete the function body */ 

void barrier() 

{ 

} 

void *parallel_elaboration(void * arg) 

{ 

int delay = rand()%6; 

int i = *(int*)arg; 

printf("[Thread %d] Waiting for %d secs...\n",i,delay); 

sleep(delay); 

printf("[Thread %d] ...elaboration finished, waiting for the other threads...\n",i); 

barrier(); 

printf("[Thread %d] ...ok!\n",i); 


} 

Continua 




int main(void) 

{ 


int params[NUM_THREADS]; 

int i, rc; 

n_threads = NUM_THREADS; 

/* Some initialization goes here... */ 

srand ( time(NULL) ); 


for (i=0; i

(fork, wait, ...) , Thread (pthread) - lucidi - Dipartimento di Ingegneria ...

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?