Initiation à la programmation

système
Chapitre : Threads
 Limitation du modèle classique des
processus
• Un processus fils est une copie indépendante de son
père.
– Synchronisation facile : chaque processus a une copie des
ressources, sauf ressources système, comme entrée TFO).
• Pas de risque d’écrasement des données de l’autre processus.
– Partage les descripteurs mais pas de la mémoire
• Communication réduite
– communication par tubes, tubes nommés.
– communication par mémoire partagée difficile.
• Communication nécessite au moins une recopie,
• Communication nécessite des protocoles parfois compliqués.
 Threads
• On peut voir un processus avec plusieurs threads
comme exécutant plusieurs "procédures" en
parallèle.
• Thread = un flux séquentiel d’instructions dans
les processus.
• Chaque thread d’un processus peut s’exécuter en
parallèle.
 Threads
• Pour chaque processus, le noyau maintient : *id,
environnement, code, données statiques, descripteurs,
tables de signaux, pile, descripteurs...
• Idéalement, un thread partage avec les autres threads du
processus tout sauf
– son identifiant (unique au sein du processus),
– ses registres, sa pile, son compteur de programme,
– des informations concernant son ordonnancement,
– sa propre valeur d’errno,
– son ensemble de signaux pendants et bloqués,
– ···,
• En particulier, les threads partagent de la mémoire (zone
statique).
• Processus = environnement d’exécution
• Thread = activité au sein d’un même environnement.
 Les threads
• Lors d’un changement de thread actif, le noyau
recharge les registres du processeur, la pile.
⇒ gain potentiel à la création de thread par rapport
à l’appel système de création de processus.
• Le partage mémoire facilite la communication.
• Partage de données importantes sans recopie.
 Exemples d’utilisation
• Partage de données volumineuses,
• Parallélisme.
• Exemples d’algorithme qui se parallélisent bien :
– tri fusion,
– traitement d’images (quad-trees),
– analyse numérique matricielle.
• Gestion des entrées utilisateurs (interfaces
graphiques/programme principal),
• Entrées multiples (multiplexage)
– un thread peut bloquer sans bloquer tout le processus
• simplification des protocoles de communication.
 API threads POSIX
• Standard IEEE POSIX 1003.1c.
• En-tête #include <pthread.h>, éventuellement
bibliothèque pthread.
• Fonctions retournent en général 0 si OK.
• Assez grosse API ( > 50 fonctions).
• Lorsqu’un programme commence, il n’a qu’un seul
thread.
– Idem après un fork() pour le fils.
– Attention, certaines variables (mutex) utilisées pour la
synchronisation des threads sont héritées par le fils.
– Idem après un exec*.
 Création de thread
int pthread_create ( pthread_t *thread_id ,
const pthread_attr_t *attr ,
void * (* routine)( void *),
void *arg);
• thread_id : identificateur (unique pour ce processus)
rempli par l’appel
• attr : permet de changer les attributs (politique
d’ordonnancement, si le thread est ou non
joignable...)
NULL ⇒ attributs par défaut
• routine : fonction de démarrage du thread
• arg : argument de cette fonction
 Attente d’un thread
int pthread_join ( pthread_t thread_id, void **
get_status);
• La fonction suspend l’exécution du thread
appelant jusqu’à ce que le thread thread_id se
termine
• Si get_status est non NULL, la valeur passée à
pthread_exit() par le thread terminé est
mémorisée à cette adresse.
 Identification des threads
pthread_t pthread_self (void);
• Renvoie l’identificateur du thread appelant.
int pthread_equal ( pthread_t thr1 , pthread_t
thr2);
• Renvoie vrai si et seulement si les arguments
désignent le même thread.
 Terminaison d’un thread
void pthread_exit(void *status );
• Termine le thread appelant en permettant à un
thread faisant un pthread_join() de connaître la
valeur de sortie status (sauf si le thread est détaché).
• pthread_join() : permet à un processus d’attendre la
terminaison d’un autre thread (équivalent du wait()).
• Pas de libération des ressources du processus, sauf
s’il s’agit du dernier thread.
• Un return x est un pthread_exit(x) implicite
– sauf pour le 1er thread main() où ça équivaut à exit(x).
 Détachement
• Par défaut, POSIX spécifie qu’un thread et joignable.
• Ceci signifie que les ressources allouées pour l’exécution
d’un thread, comme sa pile, ne sont libérées que lorsque
– le thread s’est terminé, et
– un appel à pthread_join() pour ce thread a été effectué.
• L’appel à pthread_join() permet d’accéder au code retour
effectué par pthread_exit().
• Après sa création, un thread peut se détacher = devenir
non joignable
int pthread_detach ( pthread_t thread );
• Si on n’a pas besoin du code retour d’un thread, on peut le
détacher.
• Dans ce cas, les ressources sont libérées dès la
terminaison de l’activité (et on ne peut pas attendre sa
terminaison par pthread_join()).
Exemple :
void *hello( void *arg ) {
int *id = (int*)arg;
printf("%d: hello world \n", *id);
pthread_exit(NULL);
}
int main (int argc, char *argv[ ]) {
pthread_t thread[3];
int id[3]={1,2,3};
int i;
for (i=0;i<3;i++) {
printf("Cree thread %d\n",i);
pthread_create(&thread[i], NULL,hello, (void *)&id[i]);
}
pthread_exit(NULL);
}

$gcc -pthread -o thread_ex thread_ex.c