Théorie des Systèmes

d’exploitation
TD N°3 : Gestion des processus
s_ouatik@yahoo.com
hliwaghizlane@gmail.com
hadi@uit.ac.ma
 Exercice 3: (TD 3)

Le modèle de producteur/consommateur est un exemple classique de synchronisation de

deux processus, l’un produit des informations (des messages) qu’il dépose dans un tampon
(buffer) de taille bornée, l’autre qui les retire une à une pour les consommer.
Ce problème induit plusieurs types de contraintes de synchronisation qui sont:
• Un producteur ne doit pas produire, ni déposer le message dans le buffer quand il n y a
plus de place pour déposer ce qu’il a produit.
• Un consommateur ne doit pas retirer de messages quand le buffer est vide.
• Le producteur et consommateur ne doivent pas accéder en même temps au buffer
(partagé).
Exercice 3: (TD 3)
On propose le code qui suit :
Initialisation :
Semaphore Mutex = 1;
Message tampon[];

Producteur Consommateur
Producteur( ) Consommateur( )
{ {
Message m ; Message m ;
Tant que Vrai faire Tant que Vrai faire
{m = creermessage() ; {
down(Mutex) ; dwn(Mutex) ;
EcritureTampon(m); m = LectureTampon();
Up(Mutex) ; up(Mutex) ;
} }
} }
Question : Cette solution permet-elle d’assurer l’exclusion mutuelle ? Quelle
est sa limitation ?
 Exercice 3: (TD 3)

Question : Cette solution permet-elle d’assurer l’exclusion mutuelle ? Quelle

est sa limitation ?

Oui. Cette solution permet assurer l’exclusion mutuelle par le biais du sémaphore utilisée
(Mutex)

Elle ne permet pas la synchronisation entre le producteur et le consommateur.

 Exercice 3: (TD 3)
1) Adapter cette solution pour que l'échange des messages soit synchronisé (consommateur
bloqué si le tampon est vide, et producteur bloqué si le tampon est plein).
Initialisation :
Semaphore Mutex = 1;
Message tampon[];

Producteur Consommateur
Producteur( ) Consommateur( )
{ {
Message m ; Message m ;
Tant que Vrai faire Tant que Vrai faire
{m = creermessage() ; {
down(Mutex) ; dwn(Mutex) ;
EcritureTampon(m); m = LectureTampon();
Up(Mutex) ; up(Mutex) ;
} }
} }
 Exercice 3: (TD 3)
Initialisation :
1) Adapter cette Semaphore Mutex = 1;
Semaphore Empty = N;
solution pour que Semaphore Full = 0;
l'échange des Message tampon[];
messages soit Producteur Consommateur
synchronisé
(consommateur Producteur( ) Consommateur( )
bloqué si le tampon { {
est vide, et Message m ; Message m ;
producteur bloqué si Tant que Vrai faire Tant que Vrai faire
{m = creermessage() ; {
le tampon e st plein). down(Empty); down(Full);
down(Mutex) ; dwn(Mutex) ;
EcritureTampon(m); m = LectureTampon();
Up(Mutex) ; up(Mutex) ;
Up(Full); Up(Empty);
} }
} }
Exercice 3: (TD 3)
2) Cette solution est-elle correcte dans le cas de plusieurs producteurs et
plusieurs consommateurs ? Justifier.
Exercice 3: (TD 3)
2) Cette solution est-elle correcte dans le cas de plusieurs producteurs et
plusieurs consommateurs ? Justifier.

Oui. Cette solution est correcte dans le cas de plusieurs producteurs et plusieurs
consommateurs.
- L’exclusion mutuelle est assurée par l’usage du sémaphore Mutex.
- La synchronisation est assurée par l’usage des deux sémaphores empty et full.
Les 3 sémaphores seront utilisés et partagés par l’ensemble des processus.
L’avantage est que toutes les opérations down et up sur les sémaphores sont
indivisibles.