#include <pthread.

h>
pthread_t pthread_self(void);
Faculté des Sciences de Tunis
int pthread_equal (pthread_t tid_1, pthread_t tid_2) ;
Département des Sciences de l'Informatique

Système d’exploitation • pthread_self() retourne l’identificateur du thread courant dans le processus courant (le tid).
TP – Threads Posix • pthread_equal(tid_1,tid_2) retourne 0 si les deux identités transmises en argument sont
Threads identiques et une valeur non nulle sinon.

La création d’un nouveau processus par la primitive fork() nécessite la copie complète du contexte du
Terminaison
processus père. Cela a l’avantage de la simplicité mais est d’une part particulièrement coûteux en temps
d’exécution pour le système et d’autre part pas toujours adapté aux applications avec beaucoup de Tous les threads d’un même processus prennent fin si l’activité initiale prend fin ou si une des activités fait
parallélisme. Les threads, qu’on appelle aussi processus légers ou activités, sont des unités d’exécution des appel à la primitive exit() (ou _exit()). Une activité seule prend fin automatiquement quand la fonction
processus : ils travaillent directement avec les structures de données dédiées au contrôle (voir Section 1.1, passée en argument de la primitive pthread_create retourne. Les ressources allouées pour une activité
catégorie 1) du processus père, qu’on appellera plus justement activité initiale. Leur temps de création est ne sont jamais libérées automatiquement. Les primitives de terminaison d’un thread (sans affecter les autres
minimal pour le système (qui n’a plus besoin que de copier les structures de données dédiées à l’exécution, activités) et de libération de ses ressources sont les suivantes :
voir Section 1.1, catégorie 2). Cependant leur manipulation est plus délicate pour les programmeurs qui
doivent être parfaitement conscients des problèmes liés au travail en mémoire partagée et à l’aise avec les #include <pthread . h>
solutions telles que les sémaphores d’exclusion mutuelle. void pthread_exit ( void ∗ p_status) ;
int pthread_detach ( pthread_t tid ) ;
En particulier, on notera que le code, les variables globales et la mémoire allouée dynamiquement sont
partagés entre les différentes activités d’un même processus. De même, bien qu’elle ne soit connue
directement que d’une activité, une variable locale dans la pile d’une activité peut être lue ou modifiée • pthread_exit(p_status) termine l’activité qui l’a appelée en indiquant une valeur de retour à
par une autre activité si elle en connaît l’adresse. l’adresse p_status. Cette primitive ne peut jamais retourner dans le thread qui l’a appelée.
• pthread_detach(tid) indique au système qu’il pourra récupérer les ressources allouées au thread
Création d’identifiant tid lorsqu’il terminera ou qu’il peut récupérer les ressources s’il est déjà terminé. Cette
#include <pthread.h> primitive ne provoque pas la terminaison du thread appelant. Elle retourne 0 en cas de succès, un code
d’erreur sinon. Exercices
int pthread_create(
pthread_t *p_tid, // pointeur sur identité du thread
Synchronisation avec pthread_join
const pthread_attr_t *p_attr, //NULL attribut par défaut
void*(*fonction)(void *), // Fonction exécuté par le thread Lorsque nous créons des threads puis nous laissons continuer par exemple la fonction main, nous prenons le
risque de terminer le programme complètement sans avoir pu exécuter les threads. Nous devons en effet
void *arg); //paramètres de la fonction
attendre que les différents threads créés se terminent. Pour cela, il existe la fonction :

La primitive pthread_create crée une nouvelle activité et renvoie son identité à l’adresse p_tid (il int pthread_join (pthread_t th, void ** thread_return);
s’agît d’un numéro entier non signé qui servira par la suite à la gestion du thread). Son argument attr définit Ses arguments sont dans l'ordre :
les attributs du thread (nous utiliserons toujours NULL, qui donne les attributs par défaut), fonction est
Le thread à attendre.
un pointeur sur la fonction qui sera exécutée par l’activité (cette fonction retourne nécessairement un void
* et prend nécessairement un unique argument de type void *). Enfin, le dernier argument arg correspond La valeur de retour de la fonction du thread th.
à l’argument transmis à la fonction fonction. Cette primitive retourne 0 en cas de succès, un code d’erreur
L'appel de cette fonction met en pause l'exécution du thread appelant jusqu'au retour de la fonction. Si aucun
sinon.
problème n'a eu lieu, elle retourne 0 (zéro) et la valeur de retour du thread est passé à l'adresse indiquée
(second argument) si elle est différente de NULL. En cas de problème, la fonction retourne une des valeurs
Identité
suivantes :
Chaque processus a un numéro unique, le pid, qui est renvoyé par la primitive getpid(). Tout processus
ESRCH : Aucun thread ne correspond à celui passé en argument.
est lui-même décomposé en threads qui ont chacun leur identifiant unique pour un même processus, le tid.
On notera l’activité tid (par exemple 5) du processus pid (par exemple 1234) sous la forme [Link] EINVAL : Le thread a été détaché ou un autre thread attend déjà la fin du même thread.
(par exemple 1234.5). Deux primitives sont dédiées à la manipulation des identités des activités :
EDEADLK : Le thread passé en argument correspond au thread appelant.