Centre d’excellence IT
Rapport de travaux pratiques :
Niveau : Licence d’excellence
Filière : Ingénierie Logicielle
Module : Programmation Temps Réel
Année universitaire 2025-2026
Réalisé par : Zainab Bakkas
Exercice 1 : Théorique – Comparaison Mutex/Sémaphore :
Les mutex et les sémaphores sont deux mécanismes de synchronisation utilisés pour éviter les
problèmes d’accès concurrent aux ressources dans un programme multi-thread. Leur
similarité principale est qu’ils permettent tous les deux :
De protéger une section critique : lorsqu’un thread entre dans cette zone, les autres
doivent attendre.
De bloquer un thread jusqu’à ce qu’il puisse accéder à une ressource ou entrer dans la
section critique.
La différence entre un mutex et un sémaphore :
Le mutex est conçu pour protéger une ressource critique en n’autorisant qu’un seul thread à la
fois à y accéder. Lorsqu’un thread verrouille le mutex, aucun autre ne peut l’obtenir jusqu’à
ce qu’il soit libéré, ce qui garantit une exclusion mutuelle stricte.
À l’inverse, le sémaphore offre plus de flexibilité : il permet de gérer plusieurs ressources
partagées simultanément grâce à son compteur interne. Il est également très utile pour
synchroniser un grand nombre de threads, en contrôlant quand chacun peut avancer dans son
exécution. De ce fait, un sémaphore peut autoriser plusieurs threads à accéder à la ressource
en même temps, tant que le compteur n’est pas épuisé.
Un exemple pratique :
Pour mutex : gestion et protection d’une variable partagé entre deux threads.
Pour Sémaphores : pool de connexions, buffer des taches, fil d’impression.
Exercice 2 : Pratique – Sémaphore pour limiter l’accès :
Cinq utilisateurs (threads) veulent accéder à trois imprimantes partagées. Le programme
utilise un sémaphore comptant pour contrôler l’accès. Après avoir inclus les bibliothèques
nécessaires, le sémaphore est initialisé à 3, correspondant au nombre d’imprimantes
disponibles. Chaque thread attend avec sem_wait() jusqu’à ce qu’une imprimante soit libre,
puis “imprime” pendant un certain temps avant de libérer l’imprimante avec sem_post(). Et, le
sémaphore garantit qu’au maximum trois utilisateurs impriment simultanément, tandis que les
autres attendent leur tour, assurant une synchronisation correcte et évitant les conflits d’accès.
Exercice 3 : Pratique – Synchronisation avec Verrous Conditionnels :
Ce programme montre le problème de producteur/consommateur avec un buffer limité, en
utilisant des threads, un mutex et des variables de condition pour gérer la synchronisation.
Nous avons inclus les bibliothèques nécessaires (stdio.h pour l’affichage, pthread.h pour les
threads, unistd.h pour les délais, et stdlib.h), le programme définit un buffer de taille 5 et un
compteur pour suivre le nombre d’éléments présents. Le mutex protège l’accès au buffer afin
qu’un seul thread à la fois puisse le modifier, tandis que les variables de condition not_full et
not_empty permettent aux threads d’attendre lorsque le buffer est plein ou vide, sans le
bloquer.
Le programme crée deux threads sont un producteur, qui produit 10 éléments et les ajoute au
buffer, et un consommateur, qui consomme 10 éléments du buffer. Si le buffer est plein, le
producteur attend (pthread_cond_wait(¬_full, &mutex)) jusqu’à ce qu’une place se libère,
et une fois qu’il ajoute un élément, il signale le consommateur
(pthread_cond_signal(¬_empty)). De plus, si le buffer est vide, le consommateur attend
(pthread_cond_wait(¬_empty, &mutex)), puis signale le producteur après avoir
consommé un élément (pthread_cond_signal(¬_full)). Le programme principal attend la
fin des threads avec pthread_join et libère les ressources avec pthread_mutex_destroy et
pthread_cond_destroy.
Exercice 4 : Pratique – Synchronisation dans une section critique :
Ce programme montre l’utilisation des threads et d’un mutex pour calculer la somme des
nombres de 1 à 100 en parallèle. Nous avons inclus les bibliothèques nécessaires (stdio.h pour
l’affichage et pthread.h pour les threads), le programme déclare une variable globale sum pour
stocker la somme totale et un mutex pour protéger cette variable lors des accès concurrents.
La fonction compute_sum reçoit un intervalle [start, end] et calcule la somme locale des
nombres dans cette plage. Une fois le calcul local terminé, le thread verrouille le mutex avec
pthread_mutex_lock pour ajouter sa somme locale à la variable globale sum, puis déverrouille
le mutex avec pthread_mutex_unlock afin de permettre à l’autre thread de faire de même.
Cela pour éviter la condition de course.
Dans la fonction principale main, nous créons les deux threads, le premier calcule la somme
de 1 à 50 et le second de 51 à 100. Le programme attend leur terminaison avec pthread_join
avant d’afficher la somme totale.
A la fin, ce programme montre comment réaliser un calcul parallèle en utilisant des threads et
un mutex pour protéger les ressources partagées.