Libreria Linux Threads. Threads nel S.O. Linux. Primitive per la gestione dei thread. Portabilità: libreria pthreads (Posix).

Transcript

1 Threads nel S.O. Linux Il thread è un processo leggero che può condividere uno spazio di indirizzi (o parte di esso) con il padre e gli altri processi della gerarchia cui appartiene. Realizzato a livello kernel: è l unità di scheduling. Clone: system call nativa per la generazione dei thread. Si può specificare quale parte dello spazio di indirizzamento mettere in comune tra padre e figlio. Caratteristica di Linux e quindi non portabile. Libreria Linux Threads Portabilità: libreria pthreads (Posix). Varie realizzazioni in ambiente Linux della libreria pthreads. Linux Thread. Ogni programma è rappresentato da uno o più thread. Thread identifier (TID) Ogni thread appartiene al tipo pthread-t (header file <pthread>) Lo standard POSIX prevede che i thread vengano creati all interno di un processo (task). In LinuxThreads non viene realizzato il concetto di task. La esecuzione di un programma determina la creazione di un thread iniziale che esegue il codice specificato dal main. Il thread iniziale può essere il capostipite di una gerarchia di thread che condividono uno spazio di indirizzi (concettualmente equivalente al task). Primitive per la gestione dei thread pthread_create creazione di un nuovo thread. pthread_exit terminazione di un thread. pthread_join sospensione del padre in attesa della terminazione di un figlio. 1

2 Creazione thread int pthread_create (pthread_t*t, pthread_attr_t*a, void *(*cod)(void*arg)); Libreria p-thread: Sincronizzazione dei thread T A cod arg T puntatore alla variabile che contiene il TID del nuovo thread attributi del thread (es:priorità) puntatore alla funzione che contiene il codice del nuovo thread puntatore al vettore che contiene i parametri per la funzione - mutex (semaforo binario) - variabili condizione LinuxThreads realizza anche i semafori (POSIX b, libreria <semaphore.h>). Mutex Astrazione simile al concetto di semaforo binario. Il valore può essere 0 oppure 1 (occupato o libero) Sono utilizzati per risolvere problemi di mutua esclusione. mutex è definito dal tipo pthread_mutex_t che rappresenta: -lo stato di mutex - la coda dei processi sospesi in attesa che mutex sia libero. Su mutex sono possibili solo due operazioni: locking e unlocking (equivalenti a wait e signal sui semafori): pthread_mutex_lock (pthread_mutex_t *M) se M è occupato (stato 0), il thread chiamante si sospende nella coda associata a M; altrimenti occupa M. pthread_mutex_unlock (pthread_mutex_t *M) se vi sono processi in attesa di M, ne risveglia uno, altrimenti libera M. 2

3 Variabili condizione (condition) Strumento di sincronizzazione: consente la sospensione dei thread in attesa che sia soddisfatta una condizione logica. 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. Operazioni fondamentali: wait (sospensione) signal ( risveglio) P_thread realizza la variabile condizione mediante il tipo di dato: es: p_thread_cond_t p_thread_cond_t C Operazioni fondamentali: inizializzazione: p_thread_cond_ init sospensione: risveglio: p_thread_cond_ wait p_thread_cond_ signal /*variabili globali*/ p_thread_cond_t C int bufferpieno=0 /* codice produttore:*/ if (bufferpieno) <sospensione su C> <inserimento messaggio nel buffer> /*variabili globali*/ p_thread_cond_t C; p_thread_mutex M; int bufferpieno=0; p_thread_mutex_lock(&m); /* codice produttore:*/ La verifica della condizione (if buffer pieno) è una sezione critica. Ad ogni variabile condizione va associato un mutex. buffer> if (bufferpieno) <sospensione su C> <inserimento messaggio e aggiornamento del p_thread_mutex_unlock(&m); 3

4 L uso della condition prevede l introduzione di un mutex: Effetti: int p_thread_cond_wait (p_thread_cond_t*c; p_thread_mutex_t*m) -C: variabile condizione -M: mutex associato a C int p_thread_cond_signal (p_thread_cond_t*c ) Se esistono thread sospesi nella coda associata a C, viene risvegliato il primo. Se non vi sono thread sospesi sulla condizione, la signal non ha effetto. T viene sospeso nella coda associata a C M viene liberato al risveglio di T, M viene rioccupato automaticamente Esempio 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*/ 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); <uso della risorsa> /*fase di uscita*/ pthread_mutex_lock(&m); /*aggiorna lo stato della risorsa */ N-in --; pthread_cond_signal(&pieno); pthread_mutex_unlock(&m); } 4

5 Linuxthreads:Semafori (POSIX b). Libreria <semaphore.h> sem_t: tipo di dato associato al semaforo: sem_t my_sem Operazioni sui semafori: sem_init: inizializzazione di un semaforo sem_wait : wait sem_post: signal int sem_init (sem_t*sem,, unsigned int value) sem semaforo da inizializzare value: valore iniziale da assegnare al semaforo int sem_wait(sem_t*sem) Se il valore del semaforo è uguale a zero, sospende il thread chiamante nella coda associata al semaforo;altrimenti ne decrementa il valore. int sem_post(sem_t*sem) Se c è almeno un thread sospeso nella coda associata al semaforo sem, viene risvegliato; altrimenti il valore del semaforo viene incrementato. 5