Université Mohammed V

Ecole Nationale supérieure d’informatique et d’Analyse

des Systèmes
ENSIAS

Compte rendu 2
TP N°2 : Les Threads : Fonctionnement, Communication,
Synchronisation et Clonage
Nom et Prénom : Hanane ABID

Master1: Cloud and High Performance Computing-CLOUDHPC

Annee universitaire: 2019-2020

I. Objectifs du travail :
 faire communiquer des threads ;
 comprendre le fonctionnement des threads ;
 faire synchroniser des threads ;
 le clonage des processus.

II. Etapes de réalisation :

A. Ordonnancement et Synchronisation des Threads.

Exercice 1 :

Figure 1 : création d’un thread fil qui affiche le caractère « x »

Apres l’exécution du programme de la figure 1 on obtient comme résultat ce qui suit :

Figure 2 : la sortie du programme de la figure 1

Explication : dans la fonction main de ce programme, on a créé un thread par la déclaration

d’une variable de type pthread_t , qui stockera l’identifiant du thread, puis par un appel
de la fonction pthread_create en lui passant dans les paramètres la fonction de thread void*
print_xs (void* args).

La fonction main contient une boucle infinie qui affiche les ‘o’ et le thread affiche
continuellement les ‘x’ sur l’écran.

Exercice 2 :

1. Le programme exo2.c :

Figure 3 : création deux threads (exo2.c)

Apres l’exécution du programme exo2.c, on n’obtient rien comme affichage :

Figure 4 :la sortie du programme exo2.c

2. Explication : le programme est bogué. La même fonction de thread, char_print, est

utilisée par les deux threads mais chacun est configuré différemment en utilisant
une struct parms.

3. Proposition : forcer main à attendre la fin des deux autres threads. Ce dont nous avons
besoin a une fonction similaire à wait qui attende la fin d'un thread au lieu de celle d'un
processus. Cette fonction est pthread_join, qui prend deux arguments: l'identifiant du
thread à attendre et un pointeur vers une variable void* qui recevra la valeur de retour du
thread s'étant terminé.

Figure 5 :fonction main révisée du programme exo2.c (exo2V2.c)

Apres l’exécution du programme exo2V2.c on obtient comme résultat ce qui suit :

 Figure 6 :la sortie du programme exo2V2.c

B. Synchronisation et Sections Critiques :

Exercice 4 : Mutexes

Figure 7 : Fonction Thread Job Queue, protégée par un Mutex

Exercice 5 : Sémaphore
 Figure 8 :programme d’un file d’attente contrôlée par sémaphore (exo5.c)

Figure 9 : la suite du programme exo5.c

Apres l’exécution du programme exo5.c, on obtient les résultats suivants :

 Figure 10 :la sortie du programme exo5.c

Exercice 6 : variables de condition

Figure 11 : programme d’implémentation d’une variable de condition

III. Conclusion :
 Tous les threads d'un programme doivent exécuter le même exécutable.

 Un thread errant peut endommager d'autres threads dans le même processus car les
threads partager le même espace de mémoire virtuelle et d'autres ressources ;

 Les threads doivent être utilisés pour les programmes qui nécessitent un
parallélisme à grain fin. Pour Par exemple, si un problème peut être divisé
en plusieurs tâches, threads presque identiques, peut être un bon choix ;

 Le partage de données entre les threads est trivial car les threads partagent la même
mémoire cependant, un grand soin doit être pris pour éviter les conditions de
concurrence ;

 Problèmes de terminaison et d’inter blocages.

IV. Problèmes rencontrés :

Parmi les problèmes rencontrés durant la réalisation de ce TP, je n’arrive pas à bien
comprendre l’utilisation des fonctions de clonages, ce qui m’a interrompue de réaliser
exercice 7.

V. Questions :
 Est-ce que on peut associer des threads à des serveurs ?
 Est-il autorisé de lancer un nombre de thread supérieur au nombre de clients que
peut accepter simultanément le serveur ?