UMBB _Fac des sciences Année universitaire 2021-2022

Département d’informatique Semestre 5_ Matière : SE2

TP2 : les threads (processus légers)

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). De
nombreux systèmes d’exploitation modernes offrent la possibilité d’associer à un même
processus plusieurs chemins d’exécution (multithreading, multi flot d’exécution).

• 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.
• 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..

Remarque
Le principal avantage des threads par rapport aux processus, c'est la facilité et la rapidité de
leur création. En effet, tous les threads d'un même processus partagent le même espace
d'adressage, et donc toutes les variables. Cela évite donc l'allocation de tous ces espaces lors
de la création, et il est à noter que, sur de nombreux systèmes, la création d'un thread est
environ cent fois plus rapide que celle d'un processus.

Gestion des threads

Les primitives de création et de gestion des threads ressemblent aux primitives de création et
de gestion des processus :
 Chaque thread est identifié par un objet de type pthread_t.
 Pour pouvoir gérer les threads, il faut ajouter, # include <pthread.h>
 Ensuite, il faut ajouter un «-lpthread» à l'édition de lien (lors de la compilation).

Création: pthread_create(&tid, &attr, &fonc, arg)

1. &tid: un pointeur vers une variable pthread_t, dans laquelle l'identifiant du nouveau thread
sera stocké;
2. &attr: un pointeur vers un objet d'attributs de thread. Cet objet contrôle les détails de
l'interaction du thread avec le reste du programme. Si vous passez NULL comme argument de
thread, le thread est créé avec les attributs par défaut.
3. &fonc : un pointeur vers la fonction de thread.
4. Arg : une valeur d'arguments de thread de type void*. Quoi que vous passiez, l'argument
est simplement transmis à la fonction de thread lorsque celui-ci commence à s’exécuter.

pthread_self() : retourne l'identifiant du thread.

pthread_exit(status) : met fin à la fonction.
pthread_cancel(tid) : annulation d'un thread.
pthread_join(tid, &status): permet d'attendre la fin d'un thread tid et récupère son status.
pthread_detach(tid): détache un thread des autres threads.

1
UMBB _Fac des sciences Année universitaire 2021-2022
Département d’informatique Semestre 5_ Matière : SE2

TP1 :
Programmer l’exemple suivant et observer les sorties
#include <pthread.h>
#include <stdio.h>
int var =0;
void* fonc1 (void* arg){
printf("fils %ld : début\n", pthread_self()) ;
sleep(1) ;
var=10 ;
printf ("fils %ld : modification de var=%d\n", pthread_self(), var) ;
sleep(10);
printf("fils %ld : fin\n", pthread_self()) ;
return NULL ;
}
int main()
{
pthread_t tid;
printf("père %ld : début (var=%d)/n", pthread_self(), var);
pthread_create(&tid, NULL, fonc1, NULL) ;
printf ("père %ld : creation de thread %ld\n", pthread_self(), tid);
sleep(5) ;
printf("père %ld : fin (var= %d)\n", pthread_self(), var);
return 0 ;
}

TP2 (passage d'argument à un thread)

Écrire un programme qui crée un thread qui dort un nombre de secondes passé en
argument, pendant que le thread principal attend qu'il se termine.
#include <pthread.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
void *fonc (void *arg){
int nbsec = (int)arg;
printf("je suis un thread et j'attends %d secondes\n", nbsec);
sleep(nbsec);
puts("je suis un thread et je me termine");
pthread_exit(NULL); /* termine le thread proprement*/
}
int main(void)
{
int ret;
pthread_t tid ;
int nbsec;
time_t t1;
srand(time(NULL));
t1=time(NULL);
nbsec= rand()%10; /* on attend entre 0 et 9 secondes*/
/* on crée le thread*/

2
UMBB _Fac des sciences Année universitaire 2021-2022
Département d’informatique Semestre 5_ Matière : SE2

ret=pthread_create(&tid, NULL, fonc, (void*)nbsec);

if (ret != 0)
{
fprintf(stderr, "erreur de creation de thread");
exit(1);
}
pthread_join(tid, NULL);
printf("dans le main, nbsec =%d\n", nbsec);
//printf("durée de l'opération =%d\n", time(NULL)-t1);
return 0;
}
Exercice 1 (*)
Écrire un programme qui crée un thread qui prend en paramètre un tableau d'entiers et
l'affiche dans
la console.
Exercice 2 (**)
Créer une structure TypeTableau qui contient qui contient :
• un tableau d'entiers.
• le nombre d’éléments du tableau.
• un entiers x.
Écrire un programme qui crée un thread qui initialise un TypeTableau avec des valeurs
aléatoires entre 0 et 99. Le nombre d'éléments du tableau est passé en paramètre. Dans le
même temps, le thread principal lit un entiers x au clavier. À la fin du remplissage du tableau,
le programme crée un thread qui renvoie 1 si l'élément x est dans le tableau, 0 sinon.