Un thread è costituito dal program counter, da un inseieme di registri e da uno stack. Un thread condivide con altri threads concorrenti la sezione di codice, la sezione di dati e le risorse del sistema operativo, come i file aperti e i segnali. In un processo composto da più thread nel caso in cui un thread sia in attesa si può eseguire un altro thread dello stesso processo. I processi sono indipendenti mentre i thread possono avere risorse comuni.
Esistono principalmente due tipi di thread. Lo user-level thread sono supportati mediante chiamate di sistema a livello utente. I vantaggi sono velocità tra threads dello stesso processo e si possono implementare su un kernel qualunque. Gli svantaffi ci sono nel momento in cui un thread effettua un'operazione bloccante perchè vengono bloccati tutti i thread dello stesso processo e in più vengono eseguiti sequenzialmente anche in un sistema multiprocessore. I kernel thread inveve sono generati chiamando system calls. Sono gestiti dall'OS e quindi pososno essere schedulati e eseguiti in parallelo su un sistema multiprocessore. Il context switch è però più costoso ed è necessario stabilire un massimo di thread per processo.
pthread_attr_init(p_thread_attr_t *attr) setta gli attributi di default
pthread_create(pthread_t *tid, p_thread_attr *attr, void *funzionedaeseguiredalthread, argv[1]) crea un nuovo thread
pthread_join(tid, NULL) attende l'uscita del thread
pthread_exit(int )termina il thread con valore di uscita
pthread_self() restituisce il pid del thread chiamante
In Unix se si chiama la exec() viene creato un nuovo processo con tutti thread, con la fork() no.
pthead_kill(pthread_t tid, int signal) permette di inviare un segnale a un thread specifico.
Se viene chiamata un exit vengono terminati anche tutti i thread.
Sincronizzare i processi
Un metodo è tramite le funzioni start che fa si che il processo si dirami in due flussi. Nel momento in cui si chiama la complete i due flussi si riuniscono e riprendono lo stesso flusso di esecuzione. Un altro metodo è la begin in cui si chiamano altri processi che eseguono altre parti di codice. Il costrutto cobegin permette l'esecuzione in parallelo di più processi. Coend aspetta la loro fine. Con questi costrutti non è possibile realizzare ogni tipo di grafo. Le regole per la concorrenza sono espresse dalle condizioni di Bernstein che dicono che gli scrittori non possono scrivere quando qualcuno scrive o legge. Questo è il principio su cui si basa la mutua esclusione.
Implementazione in C
Reader
while (true)
{ flag[i]=TRUE;
turn=j;
while(flag[j] && turn==j);
Sezione critica
flag[i]=FALSE;
Sezione non critica
}
Writer
while (true)
{
flag[j]=TRUE;
turn=i;
while(flag[i] && turn == i);
Sezione critica
flag[j]=FALSE
Sezione non critica
}
Altre soluzioni possibili possono essere quella di disabilitare gli interrupt se si è in regione critica, nei sistemi monoprocessori. Un altro metodo è quello di utilizzzare un bit che indica se ci si trova in sezione critica, ma questo è utilizzabile solo nei sistemi monoprocessore a memoria comune. Tramite gli event flag si possono sincronizzare eventi:
Sender
while(TRUE) {
...
cause e;
}
Receiver
while(TRUE)
{
await(e);
...
}
Per le immagini Ringraziamo ©funny bunny
| < Prec. | Succ. > |
|---|
