TD Threads
Exercice 1 : Création et attente de threads
Écrivez un programme ayant le comportement suivant :
1. Des threads sont créés (leur nombre étant passé en paramètre lors du lancement du
programme) ;
2. Chaque thread affiche un message (par exemple hello world ! )
3. Le thread principal attends la terminaison des différents threads crées.
Exercice 2: identification des threads
Modifiez le programme de la question précédente pour que chaque thread affiche :
son PID (avec getpid()) ;
La valeur opaque retournée par pthread_self, par exemple avec printf("%p\n
", (void *) pthread self());
Exercice 3: Passage de paramètres et exclusion mutuelle
1. Modifiez le programme de la question précédente pour passer son numéro d’ordre à
chaque thread. Chaque thread doit ensuite l’afficher. Vérifiez que le numéro d’ordre
affiche par chaque thread est bien diffèrent (corrigez votre programme le cas
échéant.).
2. Déclarez une variable globale somme initialisée a 0. Chaque thread doit, dans une
boucle, ajouter 1 000 000 fois son numéro d’ordre à cette variable globale (on veut
bien faire 1 000 000 additions par thread, pas juste une). Affichez la valeur obtenue
après la terminaison de tous les threads.
Avec 5 threads (numérotés de 0 à 4), on devrait obtenir (0+1+2+3+4)*1 000 000
= 10 000 000. Corrigez votre programme s’il n’affiche pas systématiquement ce
résultat.
Exercice 4:
Ecrire un programme C qui créée deux threads partageant une variable globale glob initialisée
à 0.
Un premier thread incrément la variable globale chaque fois par un (+1) et un deuxième thread
la décrémente chaque fois par un (-1).
Si un thread, parmi les deux, arrive à avoir un écart de deux (+2 ou -2) par rapport à la valeur
initiale zéro, le jeu se termine et le thread correspondant est déclaré gagnant.
Solution
Exercice 1
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void *helloworld(void *arg) {
printf("Hello world!\n");
return NULL;
}
int main(int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "Usage: %s <num_threads>\n ", argv[0]);
return EXIT_FAILURE;
}
int nb = atoi(argv[1]);
if (nb <= 0) {
fprintf(stderr, "Number of threads must be a positive integer.\n");
return EXIT_FAILURE;
}
pthread_t *threads = malloc(nb * sizeof(pthread_t));
printf("Début de l'attente\n");
for (int i = 0; i < nb; i++) {
pthread_create(&threads[i], NULL, helloworld, NULL);
}
for (int i = 0; i < nb; i++) {
pthread_join(threads[i], NULL) ;
}
printf("Fin de l'attente\n");
return 0;
}
Exercice 2
printf("Hello world! pid=%d pthread_self=%p\n", getpid(), (void *)pthread_self())
Exercice 3
1)
pthread_create(&threads[i], NULL, helloworld, &i);
int * t = (int *) arg;
printf("Hello world! i= %d: \n",* t);
Probleme Une condition de course (race condition)
-----------------------------------------------------------------------------------------------------------------
int tab[nb];;
for (int i = 0; i < nb; i++) {
tab[i]=i
pthread_create(&threads[i], NULL, helloworld, & tab[i]);
2)
int somme = 0 :
pthread_mutex_t mutex ;
-----------------------------------------------------------------------------------------------------------------
int * t = (int *) arg ;
int ordre = * t ;
int j :
{ for (j = 0; j < 1000000; j++)
pthread_mutex_lock(&mutex) ;
somme += ordre :
pthread_mutex_unlock(&mutex) :
}
-----------------------------------------------------------------------------------------------------------------
printf("Fin de l'attente\n") ;
printf("somme=%d\n", somme) ;
Exercice 4
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
int glob = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *increment_thread(void *arg) {
while (1) {
pthread_mutex_lock(&mutex);
glob += 1;
printf("Incremented: %d\n", glob);
pthread_mutex_unlock(&mutex);
if (abs(glob) >= 2) {
printf("Increment Thread Wins!\n");
break;
usleep(100000); // Sleep for 100 milliseconds for demonstration purposes
return NULL;
void *decrement_thread(void *arg) {
while (1) {
pthread_mutex_lock(&mutex);
glob -= 1;
printf("Decremented: %d\n", glob);
pthread_mutex_unlock(&mutex);
if (abs(glob) >= 2) {
printf("Decrement Thread Wins!\n");
break;
usleep(100000); // Sleep for 100 milliseconds for demonstration purposes
return NULL;
int main() {
pthread_t increment_tid, decrement_tid;
if (pthread_create(&increment_tid, NULL, increment_thread, NULL) != 0 ||
pthread_create(&decrement_tid, NULL, decrement_thread, NULL) != 0) {
perror("Error creating threads");
return EXIT_FAILURE;
// Wait for threads to finish
pthread_join(increment_tid, NULL);
pthread_join(decrement_tid, NULL);
pthread_mutex_destroy(&mutex);
return 0;
