Primitive del linguaggio C relative ai processi

Transcript

1 Primitive del linguaggio C relative ai processi Per poter utilizzare le primitive del Linguaggio C relative ai processi occorre includere nel progetto le seguenti librerie: #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> pid_t getpid (); Restituisce il PID del processo corrente. pid_t in realtà è la ridefinizione di un int. pid_t getppid ( ) Restituisce il PID del processo padre rispetto al processo corrente. int getattribute (pid_t PID, attrstruct *) Restituisce nella struttura gli attributi del processo avente il PID indicato. Restituisce 0 in caso di successo createprocess (spawn) Alcuni SO (ad esempio VMS) mettono a disposizione una primitiva createprocess (detta anche spawn che letteralmente significa uovo, simbolo di nascita) che consente ad un processo in esecuzione (quale la shell o un qualunque altro processo utente) di creare nuovi processi figli caricando l immagine da disco. In Ansi C non esiste la spawn ma occorre utilizzare al suo posto una combinazione delle primitive fork + exec. In Visual Basic esiste invece una primitiva spawn avente la seguente sintassi: Process.Start(path.exe) int fork( ) <unistd> La system call fork consente di duplicare il processo corrente, creando un processo figlio con la stessa identica immagine di memoria del padre (stesse variabili, stessi file aperti). Il processo figlio riceve una copia dei segmenti di codice, stack e dati, ed esegue esattamente lo stesso codice del padre. Si tenga presente però che la memoria è copiata, non condivisa, pertanto padre e figlio vedono variabili diverse ed evolvono ciascuno con vita propria. Il processo figlio avrà un suo proprio ed unico PID diverso da quello del padre. In caso di successo, la funzione fork() ritorna due valori differenti, 0 al processo figlio ed il PID del processo figlio al processo padre. In caso di esito negativo, fork() ritorna -1 al processo padre, settando errno per indicare l'errore verificatosi, e non viene creato nessun processo figlio. Esempio: int ret; /* process identifier */ ret=fork(); if (ret < 0) { printf("error: Cannot fork!!\n"); exit(1); if (ret!= 0) { /* parent process */ else { /* child process */ pag 1

2 L'uso di fork ha due scopi principali: Caricamento di nuovi programmi da disco. Questo è il caso della shell, in cui il processo shell crea un processo figlio il cui unico scopo è quello di lanciare un nuovo programma da disco. Non esistendo in C la primitiva spawn occorre utilizzare una combinazione delle primitive fork + exec.. Creazione di processi figli a cui affidare l'esecuzione di una certa sezione di codice, mentre il processo padre ne esegue un'altra. È il caso tipico dei programmi server in cui il padre riceve ed accetta le richieste da parte dei programmi client, per ciascuna delle quali avvia un figlio che è incaricato di fornire il servizio (funzionalità in parte sostituita dai thread che sono più leggeri) Nota: La funzione fork duplica nei figli tutti i file descriptor aperti nel padre, il che comporta che padre e figli condividono le stesse voci della file table, come ad esempio la posizione corrente nel file. int exec(const char * path) <unistd> Le system call della famiglia exec provvedono a caricare un programma dal disco alla memoria, sostituendo l immagine del processo chiamante con l immagine del nuovo processo.. Il nuovo programma si sostituisce interamente, come dati e codice, a quello vecchio, che non e' piu' "raggiungibile". Il nuovo processo avrà però lo stesso PID del processo sostituito e manterrà inalterate le tavole file (file aperti, posizionamento all'interno di essi, relazioni con altri processi ecc.). In caso di successo le funzioni exec non ritornano alcun valore ed eventuale codice successivo alla chiamata non viene più eseguito. In caso invece di errore ritorna -1 ed il processo chiamante continua la propria esecuzione eseguendo eventuale codice successivo alla exec. La famiglia exec contempla una lista di funzioni le più importanti delle quali sono: int execl (const char * path, char * arg0, char * arg1,.... NULL). path indica il percorso completo (path + filename) dell applicazione da lanciare Attenzione che all interno del path NON sono riconosciuti i percorsi che iniziano con la tilde. arg0 è l nome del programma, più ulteriori parametri espressi singolarmente come stringa e terminati da NULL int execv (const char * path, char ** argv... NULL). argv è la lista completa dei parametri, a partire dal nome del programma, passata in un solo parametro. pid_t wait (int* status) System call utilizzata da un processo padre per attendere la conclusione di un qualunque processo figlio. Wait restituisce il PID del processo figlio che ha terminato l esecuzione, mentre restituisce all interno di status lo stato di terminazione del figlio (se il figlio termina mediante un exit, questo status rappresenta il valore passato a exit). Se un figlio è già terminato la funzione termina immediatamente. In caso di più processi figli occorre richiamare la funzione wait più volte, una volta per ogni figlio. Se si eseguono più wait rispetto al numero di figli creati, le wait eccedenti terminano immediatamente. In caso di terminazione di un processo con processi figli ancora in esecuzione, questi vengono ereditati dal processo init e viene loro assegnato un PPID = 1. Nel caso invece di terminazione di un processo figlio con il padre ancora in esecuzione senza aver richiamato wait o waitpid, il figlio non viene deallocato fino a quando il padre non farà la wait e rimane in uno stato di attesa in cui il processo è indicato come zombie. Infatti quando un processo termina invia al padre un segnale SIGCHLD che il padre può intercettare mediante le funzioni wait o waitpid, che provocano a loro volta un segnale di risposta al figlio. In caso di assenza di segnale di risposta il figlio non viene deallocato ma rimane in attesa (processo zombi). pag 2

3 pid_t waitpid (pid_t PID, int *STATUS_PTR, int OPTIONS) - (tradizionale funzione join) Ferma il padre in attesa della terminazione di uno specifico processo figlio, quello avente il PID indicato dal primo parametro (join tra padre e figlio). STATUS_PTR un puntatore ad un intero che conterrà lo stato di terminazione del processo figlio. OPTIONS è di solito impostato a 0.. Restituisce il PID del processo figlio che ha terminato Se il PID passato come primo parametro è -1 waitpid esce immediatamente. int exit (int status) System call che consente la terminazione forzata del processo corrente, chiudendo tutti i file e deallocandolo dalla memoria. Il valore del parametro status rappresenta il valore che verrà restituito alle primitive wait o waitpid utilizzate dal padre per attendere la terminazione del figlio. int sleep (int sec) tradizionale funzione delay Sospende il processo per un numero di secondi pari a sec. Ritorna il valore passato come parametro. Ad esempio il codice seguente arresta il processo per un tempo compreso tra 0 e 3 secondi. sleep (rand()%4); Al termine del tempo indicato il processo viene automaticamente riavviato. int usleep (int usec) Sospende il processo per un numero di micro secondi pari a usec. Ritorna il valore passato come parametro. Ad esempio il codice seguente arresta il processo per un tempo pari a 10 msec. usleep (10000); Al termine del tempo indicato il processo viene automaticamente riavviato. void system (char * command) Consente di eseguire un comando della shell. Ad esempio :per rimuovere un file system("rm../file1"); int kill(pid_t pid, int sig); tradizionale funzione abort System call per eseguire la terminazione forzata di un altro processo (in base ai livelli di privilegio) di cui si passa il PID. Il parametro sig indica il tipo di azione da eseguire e vale normalmente SIGKILL. In caso di successo viene ritornato il valore 0, altrimenti viene ritornato il valore -1 e la variabile errno indica l'errore specifico int pause( ) tradizionale funzione suspend Il processo e' sospeso (sempre presente nella process table ma non piu' schedulato) finche' non arriva un qualunque signal di risveglio. void * signal(int signum, void (*sighandler)(int)) tradizionale funzione resume Consente di programmare il risveglio dallo stato di WAIT del processo corrente sospeso mediante pause. La funzione signal() stabilisce che quando il processo corrente riceve il segnale signum, il controllo deve passare alla procedura indicata dal secondo parametro (che è un puntatore a funzione). Ad esempio, prima di eseguire il pause(), si può eseguire una signal(sigint, miaproc); dopo di che si esegui il pause(). Il comando SIGINT è legato al ^C. Il significato è che quando l utente premerà la combinazione ^C il sistema provvederà a risvegliare il processo richiamando la funzione miaproc. pag 3

4 Comandi dello shell per la gestione dell area di condivisione fra processi ipcs [ -asmq ] [ -tclup ] ipc show comando che consente di visualizzare informazioni riguardanti gli oggetti IPC attualmente allocati su di un computer ipcs serve per ottenere informazioni sullo stato di: shared memory [-m] code di messaggi [-q] semafori [-s] tutto [-a] (default) Il formato di visualizzazione può essere specificato nel modo seguente: -t time -p pid -c creator -l limits -u summary ipcs [ -smq ] -i id consente di visualizzare le informazioni di una risorsa specifica (quella identificata da id) ipcrm ipc remove comando che consente di disallocare semafori (-s), code di messaggi (-q), aree di memoria condivisa (-m) Es. ipcrm s Rimuove il semaforo con semid = OPTIONS -M shmkey removes the shared memory segment created with shmkey after the last detach is performed. -m shmid removes the shared memory segment identified by shmid after the last detach is performed. -Q msgkey removes the message queue created with msgkey. -q msgid removes the message queue identified by msgid. -S semkey removes the semaphore created with semkey. -s semid removes the semaphore identified by semid. ps process show elenco dei processi attivi per l utente corrente. Per ogni processo in esecuzione fornisce le seguenti informazioni : PID = numero di identificazione del processo, TTY = codice di identificazione del terminale, STAT = stato del processo, TIME Tempo di start del processo COMMAND = riga di comando con cui e' stato fatto partire il processo. opzioni - a mostra anche i processi degli altri utenti - e mostra TUTTI i processi in esecuzione, compresi quelli di root - x mostra i processi non controllati da un terminale Es ps -a grep kill Il comando kill non serve soltanto per terminare un processo, ma serve per mandare dei messaggi ad un processo. Il primo parametro rappresenta il tipo di messaggio da inviare (-9 significa terminazione). Il secondo parametro rappresenta il PID del processo a cui inviare il messaggio. Es kill // richiesta di terminazione del processo 2345 Es kill -9 xorg // richiesta di terminazione dell'interfaccia grafica pstree mostra l albero dei processi correnti pag 4

5 <sys/ipc.h> <sys/sem.h> <sys/types.h> già utilizzata per le fork(). Creazione di un gruppo di semafori Utilizzo dei SEMAFORI in Ansi C La funzione semget consente di allocare un intero gruppo di semafori. Riceve come parametro un int semkey compreso tra 1 e e restituisce un semid identificativo del gruppo di semafori creato oppure -1 in caso di errore. int semget(key_t semkey, int nsems, int options); key_t è la ridefinizione di un int (definito in <sys/types.h>) e rappresenta la chiave per identificare univocamente il gruppo dei semafori all interno del sistema. Secondo i principi del C questa chiave dovrebbe essere generata in modo casuale mediante la funzione key_t ftok(const char *pathname, int proj_id). int nsems rappresenta il numero di semafori che si intende creare all interno dell insieme. Tipicamente uno solo. int options è sostanzialmente lo stesso utilizzato dalla funzione open per l apertura di un file. Stabilisce le modalità di creazione del semaforo. E' costituito da 7 bit di modalità + 9 bit (quelli inferiori) relativi ai permessi di accesso al semaforo (creatore del semaforo, appartenenti al gruppo del creatore e tutti gli altri). Per quanto riguarda le modalità di creazione del semaforo si possono utilizzare alcune costanti predefinite e quali ad esempio IPC_CREAT (contenuta in <sys/ipc.h>) che ordina le creazione del semaforo e IPC_EXCL (contenuta in <sys/shm.h>) che, se usato congiuntamente con IPC_CREAT provoca il fallimento di semget se un insieme di semafori è già associato al valore key Per quanto riguarda invece i permessi si utilizza solitamente il valore ottale 0666 che significa , Il primo bit rappresenta il diritto di lettura del proprietario, poi il diritto di scrittura ed infine il diritto di esecuzione. Per i semafori, che sono sostanzialmente una struttura di memoria, il diritto di esecuzione non è significativo per cui non lo si assegna. Il secondo ottetto è riferito al gruppo del proprietario e l ultimo a tutti gli altri. Il valore ottale 0600 assegnerebbe i diritti di lettura e scrittura soltanto al proprietario). Ciascun semaforo dell'insieme creato da semget è internamente realizzato come una struttura di tipo sem che ne contiene i dati essenziali. Questa struttura non è direttamente accessibile in user space, ma il suo contenuto può essere letto / scritto in maniera indiretta, attraverso l'uso di apposite funzioni di controllo. Inizializzazione e Controllo del semaforo int semctl(int mid, int sem_num, int cmd, union semun arg) Restituisce 0 in caso di successo e -1 in caso di errore int mid identificativo del gruppo di semafori creati mediante semget a cui si intende accedere int sem_num indice (all interno del gruppo) del semaforo su cui si intende operare (partendo da 0) int cmd specifica il comando da eseguire. I valori più significativi per il parametro cmd sono: - SETVAL che assegna al semaforo il valore indicato dal quarto parametro. - GETVAL legge il contenuto del semaforo. Il quarto parametro viene ignorato (da omettere). In questo caso la funzione restituisce il valore letto oppure -1 in caso di errore. - IPC_RMID Rimuove l'insieme di semafori e le relative strutture dati, con effetto immediato. Tutti i processi che erano stato di sleep vengono svegliati, e ritornan un codice errore 43 (Semaforo Rimosso). Il quarto parametro union semun arg, da utilizzarsi soltanto in abbinamento a SETVAL, è una union (cioè una struttura nella quale tutti i membri hanno piazzamento zero rispetto alla base). Il primo membro di semun (il più semplice da utilizzare) è un intero che rappresenta il valore da assegnare al semaforo, per cui alla union semun si può semplicemente assegnare il valore intero a cui si intende inizializzare il semaforo. pag 5

6 Esempio di codice int create (int semkey, int valiniziale){ int mutexid, ret; mutexid = semget(semkey, 1, IPC_CREAT IPC_EXCL 0666); if (mutexid >= 0){ ret = semctl(mutexid, 0, SETVAL, valoreiniziale); if (ret == -1) mutexid=-99; return mutexid; // Rimuove il semaforo indicato da mutexid. Restituisce 0 in caso di successo int remove(int mutexid) { return semctl(mutexid, 0, IPC_RMID); // Legge il contenuto del semaforo indicato da mutexid e ne Restituisce il contenuto int read(int mutexid) { return semctl(mutexid, 0, GETVAL); Un altra funzionalità che potrebbe servire è una funzione find che consenta di individuare l identificativo del mutex a partire dalla chiave semkey di generazione del mutex. A tal fine si sfrutta ancora la funzione iniziale semget settando a 0 il terzo parametro relativo alle options. int find(int semkey) { return semget(semkey,1,0); Accessi al semaforo (wait e signal) Una volta creato ed inizializzato il semaforo, un qualunque che ne conosca il mutexid può accedere al semaforo mediante le operazioni di wait e signal che, in ANSI C sono realizzate mediante un'unica primitiva semop avente la seguente firma: int semop(int mutexid, struct sembuf *cmd, unsigned ncmd) Restituisce 0 in caso di successo e -1 in caso di errore. mutexid identificativo del gruppo di semafori creati mediante semget a cui si intende accedere ncmd = 1 indica il numero di comandi da effettuare (La funzione permette infatti di eseguire operazioni multiple sui singoli semafori dell insieme) struct sembuf *cmd, è un puntatore ad un vettore di strutture sembuf contenenti i valori relativi alle operazioni da eseguire. Le operazioni richieste vengono effettivamente eseguite soltanto se è possibile effettuarle tutte quante (atomicità). Normalmente si esegue una sola operazione alla volta assegnando il valore 1 a ncmd La struttura sembuf è articolata nel modo seguente: struct sembuf { unsigned short int sem_num; /* numero del semaforo all interno del gruppo */ short int sem_op; /* operazione da eseguire */ short int sem_flg; /* flags */ ; pag 6

7 Il campo sem_op determina l'operazione da eseguire (wait o signal). sem_op = +1 => signal In questo caso il valore di sem_op viene aggiunto al valore corrente di semval liberando la risorsa precedentemente bloccata e viene mandato in esecuzione il primo dei processi in coda. sem_op = -1 => wait Se il valore del semaforo è 0 (ROSSO) il processo cade in uno stato di WAIT finché non verrà fatta una SIGNAL oppure finchè il semaforo non verrà rimosso dalla memoria, ne qual caso la primitiva termina restituendo -1 e settando dentro errno il codice di errore 43 (Semaforo Rimosso) Il campo sem_flg consente di specificare alcuni flags il più importante dei quali è SEM_UNDO il quale fa sì che il sistema mantenga una struttura in cui vengono registrate tutte le operazioni di ogni processo sul semaforo. In questo modo, nel caso in cui il processo dovesse terminare anticipatamente senza il rilascio del semaforo, il sistema provvederà lui ad annullare eventuali azioni pendenti sul semaforo. Esempio di codice int wait(int mutexid) { struct sembuf sem_lock={ 0, -1, /* uso della risorsa */ SEM_UNDO; return semop(mutexid, &sem_lock, 1); int signal(int mutexid) { struct sembuf sem_ulock={ 0, 1, /* rilascio della risorsa */SEM_UNDO; return semop(mutexid, &sem_ulock, 1); Esempio di main #define SEMKEY 1001 int main() { Mutex * mutex = new Mutex(); int valiniziale = 1; int mid = mutex->create(semkey, valiniziale); if (mid < 0 ) { printf("errore: %d - %s ", errno, strerror(errno)); return -1; int valore = mutex->read(mid); printf("valore iniziale Semaforo (VERDE) : %d", valore); mutex->wait(mid); valore = mutex->read(mid); printf("\nvalore Semaforo dopo la Wait (ROSSO) : %d", valore); // Sezione Critica // Fine Sezione Critica mutex->signal(mid); valore = mutex->read(mid); printf("\nvalore Semaforo dopo la Signal (VERDE) : %d", valore); // Dealloca il Semaforo mutex->remove(mid); delete(mutex); pag 7

8 Utilizzo della SHARED MEMORY in Ansi C ANSI C fornisce quattro primitive fondamentali (system call) per l utilizzo della shared memory, contenute nella libreria <sys/shm.h>. Occorre però utilizzare anche le librerie base <sys/types.h> e <sys/ipc.h> Allocazione di un segmento di memoria condivisa int shmget(key_t key, int size, int permflags) La funzione shmget è del tutto analoga alla semget utilizzata nel caso dei semafori. Restituisce al solito un identificativo del segmento di memoria creato (handle o gestore del segmento) oppure -1 in caso di errore. key_t è un tipo definito in <sys/types.h> e rappresenta la chiave per identificare univocamente il segmento di memoria all interno del sistema. Secondo i principi del C questa chiave dovrebbe essere generata in modo casuale mediante la funzione key_t ftok(const char *pathname, int proj_id). In realtà, in ambito Linux, il tipo key_t è stato ridefinito come semplice int ed è pertanto possibile assegnare al parametro key un qualunque valore intero compreso tra 0 e int size rappresentala dimensione, in byte, del segmento richiesto, che viene comunque arrotondata al multiplo superiore di PAGE_SIZE. Se si fa riferimento ad un segmento esistente è possibile passare come valore 0. int permflgs è lo stesso di semget. Il valore IPC_CREAT consente la creazione della Shared Memory. Il valore 0 consente di individuare l ID di una Shared Memory esistente a partire dalla chiave key_t Attach e Detach di un segmento di Shared Memory al processo corrente void * shmat(int shmid, const void * shmaddr, int shmflg) shared memory attach Aggancia il segmento di memoria condivisa al processo corrente, in modo che questo possa accedervi direttamente come se la memoria condivisa fosse interna allo spazio di indirizzi del processo. Restituisce l'indirizzo del segmento all interno dell area di memoria del processo e -1 in caso di errore. shmid identificativo della Shared Memory a cui si intende accedere shmaddr specifica a quale indirizzo deve essere associato il segmento; impostando il valore NULL è il sistema a scegliere opportunamente un'area di memoria libera (sicuramente la scelta migliore). shmflg consente di specificare alcuni flag fra cui SHM_RDONLY che permette di agganciare la shm in sola lettura int shmdt(const void *shmaddr) Sgancia dal processo un segmento di memoria condivisa. Restituisce 0 in caso di successo, e -1 in caso di errore. shmaddr è l indirizzo locale della Shared Memory (indirizzo restituito dalla precedente chiamata a shmat con il quale la Shared Memory era stata agganciata). Operazioni di controllo sulla Shared Memory int shmctl(int shmid, int cmd, struct shmid_ds *buf) Restituisce 0 in caso di successo e -1 in caso di errore. shmid identificativo della Shared Memory a cui si intende accedere cmd specifica il comando da eseguire. I valori più significativi sono: IPC_RMID che marca il segmento di shm per la rimozione; questo verrà cancellato effettivamente solo quando l'ultimo processo ad esso agganciato si sarà staccato SHM_LOCK Abilita il memory locking sul segmento di memoria condivisa. SHM_UNLOCK Disabilita il memory locking sul segmento di memoria condivisa. buf viene utilizato soltanto per particolari valori di cmd e normalmente si imposta a NULL. pag 8

9 Esempio di classe per la gestione di una Shared Memory void * create(int semkey, int shm_size) { void * mptr; int mid; mid = shmget(shkey, shm_size, IPC_CREAT IPC_EXCL 0666); if (mid == -1) return NULL; mptr = shmat(mid, NULL, 0); /* map it into memory */ memset((void *)mptr, 0, shm_size); /* fill the segment */ return mptr; // Ricerca l identificativo della shm a partire dalla chiave key_t // e mappa la shm all interno del processo corrente // Restituisce il puntatore locale alla shm oppure NULL in caso di errore void * find(int shkey) { void * mptr; int mid; mid = shmget(shkey, 0, 0); if (mid == -1) return NULL; mptr = shmat(mid, NULL, 0); /* map it into memory */ return mptr; // Sgancia la shm dal processo corrente // Restituisce 0 in caso di successo e -1 in caso di errore int detach(void * mptr) { return (shmdt(mptr) // Rimuove la shm dalla memoria // Restituisce 0 in caso di successo e -1 in caso di errore int remove(int shkey) { int mid; mid = shmget(shkey, 0, 0); /* find shared memory ID */ if (mid == -1) { ; if (errno == EIDRM) return 0; /*EIDRM = Error Identifier ReMoved */ else return -1; /*shm già marcata per la cancellazione*/ if (shmctl(mid, IPC_RMID, NULL) < 0) { if (errno == EIDRM) return 0; else return -1; return 0; Note: Un segmento di memoria condivisa agganciato ad un processo viene ereditato da un figlio attraverso una fork, dato che quest'ultimo riceve una copia dello spazio degli indirizzi del padre. Invece, dato che attraverso una exec viene eseguito un diverso programma con uno spazio di indirizzi completamente diverso, tutti i segmenti agganciati al processo originario vengono automaticamente sganciati. Lo stesso avviene all'uscita del processo attraverso una exit pag 9

10 Utilizzo dei THREAD nello standard POSIX Lo standard ANSI C non prevede l utilizzo dei Thread. In ambiente Unix / Linux l insieme delle librerie ANSI C standard è stata ampliata con un nuovo vasto insieme di funzioni producendo un nuovo standard denominato POSIX prodotto da IEEE dove l acronimo POSIX (proposto da Richard Stallman) significa Portable Operating System Interface, con una X finale che denuncia la sua stretta relazione con i sistemi Unix. In particolare lo standard POSIX definisce una nuova libreria <pthread.h> contenente delle nuove funzioni per la gestione dei thread. Un thread non è altro che una funzione C che viene eseguita in maniera concorrente ad altre funzioni nell'ambito di uno stesso processo. Tutti i thread che fanno parte di uno stesso processo ne condividono lo spazio di indirizzamento. Le variabili che vengono dichiarate localmente all'interno della funzione che implementa il codice di ciascun thread sono private per quello specifico thread, e pertanto non accessibili da parte degli altri thread del processo: la memoria condivisa sarà pertanto rappresentata dalle variabili globali del processo. Gli identificativi dei thread sono gestiti mediante il tipo pthread_t, che è la ridefinizione di un Unsigned long int.. Abilitazione dei thread int pthread_setconcurrency (int nthread); Comunica al sistema il numero di thread che si intende creare (che tecnicamente si chiama concurrency level); Restituisce 0 in caso di successo, qualsiasi cosa diversa da 0 in caso di insuccesso. nthread rappresenta il numero di thread da creare Creazione di un nuovo thread int pthread_create (pthread_t * tid, const pthread_attr *attr, void *(*foo)(void*), void *arg); Restituisce 0 in caso di successo, qualsiasi cosa diversa da 0 in caso di insuccesso. tid è l'indirizzo dell'oggetto pthread_t destinato a contenere l'id che il sistema assegna al thread attr sono gli attributi che l'utente vuole assegnare al thread (se vale NULL vengono usati quelli di default), foo è il nome della funzione C che verrà eseguita all interno del nuovo thread arg è il puntatore ai parametri da passare alla funzione foo.deve assolutamente essere un void * Attesa per il completamento del thread int pthread_join (pthread_t tid, void ** rispt); Sospende il thread principale (genitore) in attesa che il thread identificato da tid giunga al termine. rispt rappresenta l indirizzo del puntatore al valore restituito dalla funzione foo eseguita nel thread Ritorna 0 in caso di successo, diverso da 0 altrimenti. Non è prevista invece, nello standard POSIX, una funzione di attesa di un thread generico. Altre funzioni int pthread_kill (pthread_t tid, int signo); Invia un segnale di terminazione al thread specificato dal 1 par Ritorna 0 in caso di successo, diverso da 0 altrimenti. signo è l'identificatore del segnale che si vuole inviare al thread (normalmente SIGKILL definito in "signal.h"). int pthread_self ( ); restituisce il tid del thread corrente. pag 10

11 Esempio di creazione di cinque thread identici: #define N_THREAD 5 #include <pthread.h> #include "lib.h" void * threadelabora (void * pt){ //*********LETTURA DEI PARAMETRI********* int* argpt=(int*)pt; int arg; arg=argpt[0]; //*********ELABORAZIONE************* int tid=pthread_self(); printf("sono il thread %d, Il mio TID è %u\n",arg,tid); srand(tid); // non serve in quanto rnd è nello stesso spazio di memoria attesa(6,16); printf("sono il thread %d e sto per terminare\n", arg); arg *= 2; //********* RESTITUZIONE DEL RISULTATO ************* int* rispt=(int*)malloc(sizeof(int)); //!!!!!!!!!! *rispt=arg; return (void *) rispt; int main() { int i=1; pthread_t tid[n_thread]; int nok; //*********CICLO DI CREAZIONE DEI THREAD*********** for (i=1;i<=n_thread; i++){ nok=pthread_create(&tid[i-1],null,threadelabora,(void*)&i); if (nok) { for (int j=0; j<i; j++) pthread_kill(tid[j], SIGKILL); esci("errore creazione thread"); //tra la creazione di un thread è l'altro occorre un timeout usleep(200000); //**********CICLO DI ATTESA DEI THREAD************* printf("sono il Padre. Aspetto la terminazione dei thread\n"); int * ris_pt; for (i=1;i<=n_thread; i++){ nok=pthread_join(tid[i-1],(void**)&ris_pt); if(nok) errore("errore chiusura Thread"); printf("il Thread %u è terminato con ris=%d\n",tid[i-1],*ris_pt); return 0; Per compilare un programma multithread occorre specificare il flag l pthread sulla linea di comando. gcc ese13.c l pthread -o nomeeseguibile. Eseguendo la compilazione dall interno di Eclipse impostare: menù Project / Properties / C++ Build / Settings / GCC C++ Linker / Libraries / Add / pthread pag 11