1

Programmation Système et Réseau

Chapitre 2

Les Threads
 PLAN

• Théorie de threads
•
Les processus
•
Les threads
•
Différents Threads
• Librairie pthread.h
•
Création
•
Attente de la fin d’un thread
•
Communication entre Threads
•
TP

2
 Théorie de threads(1)

• Processus unix :
Trois segments :
•
Le segment texte : code + données statiques
•
Le segment de donnée : variables
•
Le segment stack : Pile du processus

Un environnement
•
Information nécessaire au kernel pour gérer le processus
(contenu du processus, priorités, fichiers ouverts …)
•
Peut être modifié par un appel système

3
 Théorie de threads(2)

Processus :
Le modèle processus décrit précédemment est un
programme qui s’exécute selon un chemin unique
(compteur ordinal).

On dit qu’il a un flot de contrôle unique (un seul thread).

4
 Théorie de threads(3)
Threads :
De nombreux systèmes d’exploitation modernes offrent la
possibilité d’associer à un même processus plusieurs chemins
d’exécution (multithreading, multiflot d’exécution).

5
 Théorie de threads(4)
Threads :
Un thread est une unité d’exécution rattachée à un
processus, chargée d’exécuter une partie du processus.
Un processus est vu comme étant un ensemble de ressources
(espace d’adressage, fichiers, périphériques…) que ses threads
(flots de contrôle ou processus légers) partagent.

6
 Théorie de threads(5)
Threads :
Lorsqu’un processus est créé, un seul flot d’exécution (thread) est
associé au processus. Ce thread peut en créer d’autres.

Chaque thread a :
– un identificateur unique
– une pile d'exécution
– des registres (un compteur ordinal)
– un état…

7
Comment ça marche?

8
 Pourquoi utiliser les threads

• Améliorer la rapidité des applications (pas de

blocages pour des tâches qui peuvent être effectuée
en parallèle)
• Exploiter de manière efficace les machines
multiprocesseurs
• Améliorer la structure de votre programme
• Utiliser moins de ressources système

9
 Différents Threads :

Thread utilisateur :
•
Les threads utilisateur sont implantés dans une
bibliothèque (niveau utilisateur) qui fournit un support
pour les gérer.
•
Ils ne sont pas gérés par le noyau.
•
Le noyau gère les processus (table des processus) et ne se
préoccupe pas de l’existence des threads (modèle
plusieurs-à-un).
•
Lorsque le noyau alloue le processeur à un processus, le
temps d’allocation du processeur est réparti entre les
différents threads du processus (cette répartition n’est pas
gérée par le noyau).

10
 Différents Threads :

Thread Noyau:
•
Les threads noyau sont directement supportés par le
système d’exploitation.
•
Le système d’exploitation se charge de leur gestion. Du
temps CPU est alloué à chaque thread. (modèle un-à-un)
•
Si un thread d’un processus est bloqué, un autre thread du
même processus peut être élu par le noyau
•
Cette implémentation est plus intéressante pour les
systèmes multiprocesseurs.

11
 Threads : Librairie pthread.h

Création d’un thread :

int pthread_create(pthread_t *tid, const pthread_attr_t *tattr,
void*(*start_routine)(void *), void *arg);
// renvoie 0 si l’appel réussit, sinon !=0 : identifiant de l’erreur

Explication :
pthread_t *tid : ID du thread
const pthread_attr_t *tattr : les attributs du thread
(taille de la pile, priorité….)

void*(*start_routine)(void *) : La fonction à exécuter

void *arg : le paramètre de la fonction 12

 Threads : Librairie pthread.h

Exemple :
#include <pthread.h>
void* thr_f (void* param)
{
int * t = (int *) param;
printf ("parametre : %d", *t);
}
int main ()
{
pthread_t thr1;
pthread_create(&thr1,NULL,thr_f,NULL);
return 0;
}

Pour compiler ajouter l’option -lpthread 13

 Threads : Librairie pthread.h

Exercice :
Ecrire un programme qui lance deux thread, l'un affichant
50 fois 1, et l'autre 50 fois 2.

14
 Threads : Librairie pthread.h

Attendre qu’un thread se termine :

int pthread_join(thread_t tid, void **status);

Explication :
Suspend l'activité de -thread appelante tant que la thread
tid n'est pas terminée.
status contient la valeur de retour du thread tid lors de sa
terminaison.

15
 Threads : Librairie pthread.h
Exemple 2 : Partage de variable
int glob=0;
void* decrement(void * x)
{
glob = glob - 1 ;
printf("ici decrement[%u], glob = %d\n",
pthread_self(),glob);
pthread_exit(NULL);
}
void* increment (void * x)
{
sleep(1);
glob = glob + 1;
printf("ici increment[%u], glob = %d\n", pthread_self(),
glob);
pthread_exit(NULL);
}

16
 Threads : Librairie pthread.h
Exemple 2 : Partage de variable
int main( )
{
pthread_t tid1, tid2;
printf("ici main[%d], glob = %d\n", getpid(),glob);
//création d'un thread pour incrément
if ( pthread_create(&tid1, NULL, increment, NULL) != 0) return -1;
printf("ici main: creation du thread[%u] avec succes\n",tid1);
// creation d'un thread pour decrement
if ( pthread_create(&tid2, NULL, decrement, NULL) != 0) return -1;
printf("ici main: creation du thread [%u] avec succes\n",tid2);
pthread_join(tid1,NULL); // attendre la fin d’un thread
pthread_join(tid2,NULL);
printf("ici main : fin des threads, glob = %d \n",glob);
return 0;
}

17
 Threads : Librairie pthread.h

Thread et mutex :
int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

Déclarer le verrou static

Déclarer la variable partagée volatile

18
 Threads : Librairie pthread.h
Exemple 3 : Thread et mutex

Imaginons un simple tableau d'entier rempli par un thread

(lent) et lu par un autre (plus rapide). Le thread de lecture
doit attendre la fin du remplissage du tableau avant
d'afficher son contenu. Pour cela, on peut utiliser les MUTEX
afin de protéger le tableau pendant le temps de son
remplissage:

19