École Nationale d’ingénieurs de Sousse A.U.

2023-2024

TD de Programmation Concurrente (IA2)

Exercice 1. (Mutex )
Donner le code équivalent en utilisant try-lock :

i++
pthread_mutex_lock(&m1);
j++

Exercice 2. (Mutex interblocage)

Soit le code suivant.

Thread 1 Thread 2

O11: pthread_mutex_lock(&m1); O21: pthread_mutex_lock(&m2);

O12:i++ O22: pthread_mutex_lock(&m1);

O13:pthread_mutex_lock(&m2); O23: l++

O14:j++ O24: k++

O15:pthread_mutex_unlock(&m2); O25: pthread_mutex_unlock(&m1);

O16:pthread_mutex_unlock(&m1); O26:pthread_mutex_unlock(&m2);

- Donner l'arbre des exécutions possibles de ce code.

-Proposer une solution qui évite le deadlock.

Exercice 3. (Mutex et Sémaphore)

Changer le code suivant afin que les deux threads ne démarrent que qu'après l'exécution de l'instruction
l++ ; proposer une solution à base de Mutex et une autre à base de Sémaphore.

Main Thread 1 Thread 2

pthread_creat(thread 1, ) O11 O21

pthread_creat(thread 2, ) O12 O22
l++ ;
 Exercice 4. (Sémaphore pour ordonner les opérations)
Soit le code suivant.

Thread 1 Thread 2

While (1) While (1)

O11:...; O21: ...;

O12: a= f(); O22: b= a+3;

O13:...; O23: ...;

} }

Ajouter les instructions nécessaires de sorte que O22 s'exécutent toujours après O12 pour chaque itération.

Exercice 5. (Parallélisation de tâches)

L'objectif de cet exercice est de concevoir un algorithme concurrent implémenté par un programme
mulithreadé pour rechercher un élément dans un vecteur non trie. On suppose que les éléments sont de type
entier, mais le principe doit s'appliquer à tous types de données.
a) Ecrire la version séquentielle du programme : une première fonction initialise le vecteur avec des
éléments dont les valeurs sont lues à partir de l'entrée standard ; la fonction search recherche la valeur x
dans le vecteur T. Le vecteur T a une taille n. Cette fonction parcourt séquentiellement le vecteur; le
programme affiche ensuite si la valeur a été trouvée dans le vecteur.
b) Ecrire la version multithreadée du programme et en particulier de la fonction search : chaque thread
recherchera la valeur dans une portion du vecteur qui lui aura été affectée. Un thread doit pouvoir arrêter
sa recherche si un autre thread a trouvé la valeur x recherchée dans le vecteur T.

Exercice 6. (Variable de condition, arbre d’exécution)

a) Dans le code suivant, quelles sont les paires d'opérations qui ne peuvent pas être successives.
Thread 1 Thread 2
for ( ; ; ) { for ( ; ; ) {
O11: O21: pthread_mutex_lock(&mutex)
O12:pthread_mutex_lock (&mutex) O22:pthread_cond_wait(&condition,&mutex)
O13:pthread_cond_signal (&condition)
O23: pthread_mutex_unlock(&mutex)
O14:pthread_mutex_unlock (&mutex)
O24:
O15:
}
}

b) Donner l'arbre d'exécution de ce programme.

2
 Exercice 7. (variable de condition, affichage croissant)
Soit le code suivant. On souhaite obtenir un affichage croissant et ordonné des nombres, sans pour autant
perdre le parallélisme entre O11 et O21.
Donner une solution à base de sémaphores puis une autre à base de variable de condition.

Thread 1 Thread 2

for (i=0, i<N, i+=2) { for (i=1, i<N, i+=2) {

O11: O21:
O12: printf (%i) O22: printf (%i)
O13: O23:
} }

Exercice 8.

Les douches des garçons sont en rénovation à la cité universitaire. Les douches des filles serviront donc pour
les deux sexes. La salle de douches comporte quatre cabines de douches. L’ Office des Œuvres Universi-
taires impose les conditions suivantes :
- Jamais un garçon et une fille ensemble dans les douches
- Pas plus de quatre personnes (du même sexe, donc) dans les douches
- L'attente se fait à la porte
a/ En modélisant garçons et filles comme des threads indépendants, et à l'aide de sémaphores et/ou mutexs,
résolvez ce problème en utilisant le canevas suivant.
Thread_garçon { Thread_fille {
attendre (G); // G désigne garçon attendre (F); // F désigne fille
se_doucher; se_doucher;
sortir(G); sortir(F);
} }

b/ Donner une autre solution à ce problème à base de variable de condition.

Exercice 9. (Variable de condition, Alarme)

On souhaite écrire deux threads (threadCompteur et threadAlarme) : le premier incrémente un compteur par
des valeurs aléatoires et dès que la valeur du compteur dépasse 20 le deuxième thread affiche une alerte.
1) Est-ce que le code suivant répond à ce qui est demandé ?

void* threadCompteur (void* arg){ void* threadAlarme (void* arg){

int compteur = 0, nombre = 0; while(1){

... pthread_mutex_lock(&mutex);

3
 while(1) { pthread_cond_wait(&condition, &mutex);
nombre = rand()%10; pthread_mutex_unlock(&mutex);
compteur += nombre;
printf("\nLE COMPTEUR A DÉPASSÉ 20.");
if(compteur >= 20) { }
pthread_mutex_lock (&mutex); }
pthread_cond_signal
(&condition);
pthread_mutex_unlock (&mutex);
compteur = 0;
}
sleep (1);
}
}

2) Corriger le code de sorte qu'aucune alarme ne soit loupée.