TP n°5 : Les processus légers (Threads)
Exercice 1 : Écrire un programme en C qui crée un thread pour effectuer les opérations suivantes :
● Le thread demande à l'utilisateur de saisir une chaîne de caractères (par exemple : admin).
● Le thread concatène la chaîne saisie avec la chaîne de base "Bonjour".
● Le thread affiche la chaîne résultante (Bonjour admin), ainsi que son propre identifiant (Thread ID).
● Le programme principal attend la fin du thread (avec pthread_join).
● Une fois le thread terminé, le programme principal affiche son propre identifiant de processus (PID) et
la chaîne finale.
Remarque: vous pouvez utiliser pthread_self() pour afficher l’ID du thread qui est un type unsigned long
(%lu), et la fonction strcat(chaine1,chaine2) pour la concaténation, et le header <string.h>
Exercice 2 :Écrire un programme en C qui crée deux threads pour effectuer les opérations suivantes :
● Le premier thread devrait afficher son ID et lire les éléments d’un tableau d’entiers introduits par
l’utilisateur.
● Le deuxième thread devrait calculer la somme des éléments du tableau et afficher son ID ainsi le résultat
de la somme.
● Le programme principal devrait attendre d’abord la fin du thread 1, ensuite la fin du thread 2, ainsi
affiché le résultat.
Exercice 3 : Exécutez le programme suivant :
pthread_mutex_t mutex =PTHREAD_MUTEX_INITIALIZER;
int x= 0;
void *thread_function(void *arg) {
unsigned long id = *(unsigned long*)arg;
pthread_mutex_lock(&mutex);
x++;
printf("Thread = %lu : valeur de (x) partagée = %d \n",id,x);
pthread_mutex_unlock(&mutex);
return 0;}
int main() {int i;
pthread_t threads[5];
for(i=0;i<5;i++){pthread_create(&threads[i],NULL,&thread_function,&threads[i]);}
for (i=0;i<5;i++){ pthread_join(threads[i],NULL);}
pthread_mutex_destroy(&mutex);
return 0 ;}
TD n°3: Exclusion mutuelle et synchronisation
Exercice 1 : L’algorithme de Hyman (1966) proposé pour l’exclusion mutuelle s’énonce comme suit, Montrez
avec un contre-exemple que cette solution est incorrecte :
flag : tableau[0..1] d’entiers ; /*initialisé a 0*/
turn 0..1 ; /*initialisé a 0*/
processus Pi(i=0..1)
début
flag[i] ←1 ;
tant que (turn≠i) faire
1
début
tant que (flag[1-i]=1) faire ; /*attente active */
turn←i :
fin ;
<section critique>
flag[i]←0 ;
fin.
Exercice 2 : On considère un objet (un fichier par exemple) qui n’est accessible que par deux catégories
d’opérations : les lectures et les écritures. Plusieurs lectures peuvent avoir lieu simultanément, en revanche les
écritures (mises à jour) doivent se faire en exclusion mutuelle.
On appellera « lecteur » un processus faisant des lectures et « rédacteur » un processus faisant des écritures.
Il s’agit donc de réaliser la synchronisation entre lecteurs et rédacteurs en respectant les contraintes suivantes :
● Exclusion mutuelle entre lecteurs et rédacteurs : si un lecteur demande à lire et qu’il y a une écriture en
cours, la demande est mise en attente. De même que si un rédacteur demande à écrire et qu’il y a au
moins une lecture en cours, la demande est mise en attente.
● Exclusion mutuelle entre rédacteurs : si un rédacteur demande à écrire et qu’il y a une écriture en cours,
la demande est mise en attente.
1. Donnez le code des processus lecteurs/rédacteurs en utilisant la technique des sémaphores.
Exercice 3 : soit un ensemble de six tâches séquentielles {A, B, C, D, E, F}. La tâche A doit précéder les tâches
B, C, D. Les tâches B et C doivent précéder la tâche E. Les tâches D et E doivent précéder la tâche F.
1. Donnez le graphe de précédence des tâches {A, B, C, D, E, F.}
2. Réaliser la synchronisation de ces tâches en utilisant les sémaphores.
Exercice 4 : On considère deux processus un producteur (processus désirant déposer de l’information dans un
tampon T) et un consommateur (un processus désirant retirer de l’information d’un tampon T), le tampon est
géré d’une manière circulaire (0 à N-1, N-1 à 0). Les deux processus doivent respecter les contraintes de
synchronisation suivante :
• Le producteur ne peut déposer un message que s’il y a de la place disponible dans le tampon.
• Le consommateur ne peut retirer un message que s’il y en a de disponible.
• Le producteur et les consommateurs ne peuvent accéder simultanément à la même case.
• La politique de gestion du tampon est FIFO
1. Donnez le code des processus producteur/consommateur en utilisant la technique des sémaphores.
2. Supposons qu’il y’a n producteurs et n consommateurs, modifiez le code afin d’assurer l’exclusion
mutuelle.
Exercice 5 :
Deux villes A et B sont reliés par une seule voie de chemin de fer. Les trains peuvent circuler dans le même
sens de A vers B ou de B vers A. Mais, ils ne peuvent pas circuler dans les sens opposés.
On considère deux classes de processus : les trains allant de A vers B (Train AversB) et les trains allant de B
vers A (Train BversA). Ces processus se décrivent comme suit :
1. Proposez une solution qui assure la synchronisation entre les trains AversB et les train BversA en respectant
les règles de circulation sur la voie unique, sachant qu’on autorise n trains à circuler dans le même sens, en
utilisant que des sémaphores pour limiter l’accès des trains et protéger la voie de chemin de fer.
Dr. M. Baba Ahmed