Cours de systèmes

d’exploitation centralisés

Chapitre 5
Les Processus :
La Synchronisation avec
les sémaphores

Mme L. BOUZAR
© 2020-2021
-1-
1. L’Exclusion Mutuelle
2. Synchronisation des processus avec sémaphores
3. Outils de synchronisation de haut niveau:
Les moniteurs

-2-
Synchronisation des processus avec sémaphores
1. Introduction
2. Définition
3. Comment exprimer les contraintes de synchronisation ?
4. Spécification de la synchronisation
5. Les problèmes types
6. Exemples
6.1 Allocation d’une imprimante
6.2 Rendez-vous
6.2.1 Rendez-vous de deux processus
6.2.2 Rendez-vous de trois processus
6.2.3 Rendez-vous de n processus
6.3 Le modèle des lecteurs/rédacteurs
6.3.1 Ordre d’accès au fichier est quelconque
6.3.2 Ordre d’accès au fichier est FIFO
-3-
 6.4 Communication par variables communes
6.4.1 Définitions
6.4.2 Propriétés de la communication
6.4.3 Schéma général du producteur-consommateur
6.4.4 Producteur-consommateur avec un tampon à un seul élément
6.4.5 Producteur-consommateur avec un tampon à n éléments
6.4.6 Plusieurs producteurs et plusieurs consommateurs
6.4.7 Producteur-consommateur avec un tampon à éléments alloués
dynamiquement
7. La communication interprocessus : IPC Unix System V
7.1 Introduction
7.2 Identification d’une IPC
7.3 Les segments de mémoire partagée
7.3.1 Utilisation d’un segment de mémoire partagée
7.3.2 Fonctions de manipulation des segments de mémoire
partagée
7.3.3 Exemple : Création et d’utilisation d’un segment de mémoire- 4 -
7.4 Les Sémaphores Unix System V
7.4.1 Utilisation des sémaphores Unix system V
7.4.2 Création d’un ensemble de sémaphores
7.4.3 Initialisation d’un ensemble de sémaphores
7.4.4 Opérations sur un ensemble de sémaphores
7.4.5 Destruction d’un sémaphore
7.4.6 Exemple
7.5 Gestion des IPC avec des commandes shell

-5-
 La Synchronisation des processus

1. Introduction
Exemple :
 Soient deux Processus concurrents P1 et P2 qui coopèrent pour lire et
imprimer le contenu d’un fichier f.
 Le fichier f est composé d’un ensemble d’articles.
 On dispose de deux procédures :
• Lire(f, article): permet de lire un article du fichier f et le ranger
dans la zone utilisateur d’adresse « article ».
• Ecrire(article) : permet d’afficher/imprimer le contenu de la zone
utilisateur « article » sur l’écran/l’imprimante.
 On dispose en mémoire centrale d’un seul tampon qui est partagé par
les deux processus. -6-
-7-
 tampon T init(‘’’’); /* T: initialiser à vide */
Processus P1 Processus P2
Structure … artcle1; Structure … artcle2;

Début Début

Lire(article1,f);

Tantque (non(fin(f)) faire Tantque (T # ‘’fin’’) faire

Déposer (article1,T); Retirer(article2,T);

Signaler(dépôt); Signaler(retrait);

Lire(article1,f); Ecrire(article2);

Finfaire; Finfaire;

T=‘’fin’’; Fin;

Fin;
-8-
Déposer(article,T) Retirer(article,T)
Début Début
Si tampon T est plein alors Si T est vide alors
Attendre; Attendre;
T = article; Article = T;
Fin; Fin;

1) Comment faire attendre ces processus?

 P1 attend que le tampon soit vide.
 P2 attend que le tampon soit plein.

2) Comment signaler le dépôt et le retrait d’un article?

-9-
2. Définition
 « La synchronisation consiste à définir et à réaliser des mécanismes
assurant le respect des contraintes liées à la progression des
processus.
Ces mécanismes doivent être capable de faire attendre un processus
qui ferait des actions ne respectant pas ces contraintes».

· Un mécanisme de synchronisation (ou technique de synchronisation)

doit être conçu et réalisé indépendamment des vitesses d’exécution
des processus et permet à un processus actif :
 de se bloquer (attendre une ressource ou un signal d’un autre
processus);
 d’activer un autre processus en lui envoyant un signal.
· Le signal d’activation envoyé par un processus actif peut être
mémorisé ou non.
- 10 -
 Synchronisation directe et indirecte
Un mécanisme de synchronisation peut offrir deux types
d’opérations ou de primitives qui permettent à un processus d’agir
de manière directe ou indirecte sur d’autres processus :

 Le processus envoie un signal à un autre processus en le

désignant par son identificateur (ou par son nom) : 
Synchronisation directe;

 Le processus envoie un signal(sans désigner un processus), un

ou plusieurs processus en attente de ce signal sont réveillés : le
processus ne connaît pas l’identité du ou des processus
réveillés :  Synchronisation indirecte.
Exemple : Opération V sur un sémaphore.

- 11 -
3. Comment exprimer les contraintes de
synchronisation ?
1. Imposer un ordre de précédence dans le temps logique, pour l’exécution
des actions des processus .
Exemples:
a) La précédence
Exécuter l’action i du processus P1 avant l’action j du processus P2.
b) Le rendez-vous
Deux étudiants de fixent un rendez-vous pour travailler ensemble.

Etudiant 1 Etudiant 2
Début Début
. . . . . .
Attendre étudiant 2; Attendre étudiant1;
Travailler ensemble; Travailler ensemble;
- 12 -
 La forme d’un programme de rendez-vous
Debut i

. . .
Rendez-vous i; *
* Suite i;
Fin i
* i, j : fin(rendez-vous i) avant début(suite j) 
Aucun processus i ne peut exécuter la séquence suite i que si tous
les autres processus sont arrivés à leur point de rendez-vous.

2. Un processus peut être représenté à l’aide de la trace de l’exécution

de son programme.
Imposer une condition de franchissement de certains points de
leur trace temporelle.
Ces points sont appelés points de synchronisation. - 13 -
4. Spécification de la synchronisation
 La spécification d’un problème de synchronisation consiste à:
 Définir pour chaque processus ses points de
synchronisation.
 Associer à chaque point de synchronisation une condition de
franchissement.
 Les conditions sont exprimées au moyen des variables d’état du
système:
 Etat d’une ressource : libre ou occupée;
 Nombre de ressources libres;
 Nombre de ressources occupées;
 Nombre d’exécution d’une fonction d’un processus;
 Nombre de processus en attente d’une ressource donnée;
 ….
- 14 -
 Spécification de la synchronisation de l’exemple précédent

 P1 s’arrête dés qu’il y a fin de fichier.

 P2 s’arrête si le tampon T contient ‘‘fin’’.

Processus P1 Processus P2
Lire(article1,f);

tantque(non(fin(f))faire Tantque T  ‘’fin’’ faire

Déposer (article1,T); Retirer(article2,T);

Signaler(dépôt); Signaler(retrait);

Lire(article1,f); Ecrire(article2);

Finfaire; Finfaire;

T=‘’fin’’;
• - 15 -
● Points de synchronisation :
Déposer (article1,T), Retirer(article2,T), Signaler(dépôt) et
Signaler(retrait).

· Variable d’état:
Etat du tampon (vide ou plein).

· Conditions de franchissement des ces points de

synchronisation:
 Déposer (article1,T) : Si Tampon est vide ;
 Retirer(article2,T): Si tampon est plein;
 Signaler(dépôt) et Signaler(retrait) : Conditions toujours vraies.

- 16 -
5. Les problèmes types
● Les problèmes de synchronisation rencontrés dans la pratique
peuvent, dans leur grande majorité, se ramener à des combinaisons
d’un petit nombre de situations élémentaires pour lesquelles des
schémas de solutions sont connus.
● Les problèmes types peuvent être regroupés en trois classes:
1) Exclusion Mutuelle(première partie de ce chapitre)

2) Partage de ressources communes par plusieurs processus

 Allocateur de ressources banalisées,
 Modèle des lecteurs-rédacteurs.

3) Communication entre processus

 Rendez-vous,
- 17 -
 Modèle des producteurs-consommateurs.
6. Exemples :
6.1 Allocation d'une imprimante
a) m processus se partagent une seule imprimante.
· L’imprimante est une ressource critique : elle doit être utilisée en
exclusion mutuelle;
· Schéma général d’un processus i :

Processus i
Début
Demander(imprimante); Demande d’entrée en section critique
<Utiliser l'imprimante  > < section critique >
Restituer(imprimante); Sortie de la section critique;
Fin;
• L’imprimante a deux états libre ou occupé. - 18 -
● Solution avec les sémaphores
Soit slibre le sémaphore d’exclusion mutuelle protégeant cette
imprimante :
Sémaphore slibre init 1;
Processus i
Début
P(slibre);
<Utiliser l'imprimante ; >
V(slibre);
Fin;

- 19 -
b) m processus se partagent n imprimantes
Schéma général d’un processus i :
Processus i
Début
Demander(imprimante);
<Utiliser l'imprimante ; >
Restituer(imprimante);
Fin;
Il y a n imprimantes  n processus sur m peuvent travailler
(imprimer) simultanément : C’est une ressource critique à n points
d’entrée.

1) Les points de synchronisation

− Demander imprimante,
− Restituer l'imprimante. - 20 -
2) Les conditions de franchissement de ces points de
synchronisation
− Allocation d’une imprimante si nbre_imp_libre > 0 Ou
− Allocation d’une imprimante si nbre_imprimantes_allouées <
n
3) Le programme d'un processus en utilisant une variable d’état
La variable d’état représente le nombre d’imprimantes libres : nlibre.
entier nlibre init n;
Demander(imprimante) Restituer(imprimante)
Début Début

nlibre = nlibre - 1; nlibre = nlibre + 1;

si nlibre < 0 alors signaler(libération_imprimante);

attendre ; /* si processus bloqué(s) en

finsi attente d’une imprimante :

réveiller un processus) */
Fin; - 21 -
La ressource imprimante est une ressource banalisée composée de n
exemplaires. Chaque unité ou exemplaire est une ressource critique 
une imprimante ne peut être utilisée que par un seul processus à la fois.
Cette ressource à n exemplaires  n processus peuvent utiliser ces n
imprimantes en même temps(simultanement).
Solution à l’aide des sémaphores
On utilise un sémaphore représentant le nombre de ressources libres
(imprimantes libres) : slibre.

sémaphore slibre init n;

Demander(imprimante) Restituer(imprimante)

Début Début
P(slibre); V(slibre);
Fin Fin
- 22 -
4) Deux Variables d’état
Les variables d’état représentent :
• Le nombre de ressources(imprimantes) demandées : nbd,
• Le nombre de ressources(imprimantes) occupées : nbo.
• Soit nbimp une variable ou constante système contenant le nombre
d’imprimantes.
Entier nbimp init n;
Entier nbo init 0 ; Entier nbd init 0 ;
Demander(imprimante) Restituer(imprimante)
Début Début
nbd = nbd + 1; nbo = nbo - 1;
si nbo = nbimp alors attendre; Si nbd > 0 alors
Sinon nbd = nbd - 1;
nbd = nbd - 1; nbo = nbo + 1;
nbo = nbo + 1; Réveiller un processus;
finsi finsi;
- 23 -
Solution à l’aide des sémaphores :

On utilise deux sémaphores et deux variables d’états:

• Les variables d’état sont partagées par tous les processus utilisant les
imprimantes  elles doivent être protégées :
On utilise un sémaphore d’exclusion mutuelle pour les protéger.

• Pour mettre les processus en attente et pour les réveiller, on utilise un

sémaphore de synchronisation initialisé à 0.

- 24 -
Entier nbimp init n; /* variable ou constante */
Entier nbo init 0; Entier nbd init 0;
Sémaphore s init 0;
Demander(imprimante) Restituer(imprimante)
Début Début
nbd = nbd + 1; nbo = nbo - 1;
Si nbo == nbimp alors Si nbd > 0 alors

nbd = nbd – 1;
nbo = nbo + 1;
/*Attendre */ /* Réveiller un processus */
P(s); V(s);
Sinon Finsi
nbd = nbd - 1;
nbo = nbo + 1;
Finsi
Fin Fin

• Les variables nbd et nbo sont des variables partagées(ressources

critiques) : elles doivent être utilisées en exclusion mutuelle 
• Un seul processus peut exécuter une procédure Demander ou Restituer.
- 25 -
Entier nbimp init n; /* variable ou constante */
Entier nbo init 0; Entier nbd init 0;
Sémaphore mutex init 1;
Sémaphore s init 0;
Demander(imprimante) Restituer(imprimante)
Début Début
P(mutex); P(mutex);
nbd = nbd + 1; nbo = nbo - 1;
Si nbo == nbimp alors Si nbd > 0 alors
/* Sortir de la SC. avant nbd = nbd – 1;
de se mettre en attente*/ nbo = nbo + 1;
V(mutex);
/*Attendre */ /* Réveiller un processus */

P(s); V(s);
Sinon Finsi
nbd = nbd - 1;
nbo = nbo + 1;
V(mutex); V(mutex);
Finsi
Fin Fin - 26 -
6.2 Rendez-vous de processus
6.2.1 Rendez-vous de deux processus : P1 et P2
P1 P2
Début Début
… …
Signaler son arrivée à P2; Signaler son arrivée à P1;
Attendre P2; Attendre P1;
… …
Fin Fin

On utilise deux sémaphores de synchronisation initialisés à 0.

Sémaphore s1, s2 init 0 ;
P1 P2
Début Début
… …
V(s2); V(s1);
P(s1); P(s2);
… …
Fin; Fin; - 27 -
 6.2.2 Rendez-vous de trois processus : P1, P2 et P3

P1 P2 P3
Début Début Début
… … …
Signaler son arrivée Signaler son arrivée Signaler son arrivée
à P2 et P3; à P1 et P3; à P1 et P2;
Attendre P2 et P3; Attendre P1 et P3; Attendre P1 et P2;
… … …
Fin Fin Fin

On utilise deux sémaphores de synchronisation initialisés à 0.

Sémaphore s1, s2, s3 init 0;
P1 P2 P3
Début Début Début
… … …
V(s2); V(s3); V(s1); V(s3); V(s1); V(s2);
P(s1); P(s1); P(s2); P(s2); P(s3); P(s3);
… … …
Fin; Fin; Fin; - 28 -
 6.2.3 Rendez-vous de n processus : P0 à Pn-1
a) Solution avec une variable partagée(par les n processus) et deux
sémaphores :
● La variable c’est un compteur qui permet de compter les
arrivées des processus(nombre de processus arrivés).
● Deux sémaphores:
 Cette variable est partagée donc elle doit être protégée par
un sémaphore d’exclusion mutuelle initialisé à un.
 Un sémaphore de synchronisation permettant de mettre en
attente les processus; ce sémaphore est initialisé à zéro.

Entier cpt init 0;

Sémaphore mutex init 1;
Sémaphore s init 0;

- 29 -
1) Le dernier processus réveil les (n-1) processus précédents
Processus i (i=0 à n-1)
Début
P(mutex);
cpt=cpt +1;
Si cpt < n alors /* processus 0 à n-2 */
V(mutex); /* Sortir de la SC avant de se mettre en attente */
p(s); /* se mettre en attente */
Sinon /* dernier processus*/
cpt=0;
v(mutex); /* Sortir de la SC */
/* réveiller le (n-1) processus */
Pour j=1 à n-1 faire
v(s);
finpour
Finsi;
Fin
- 30 -
2) Réveil en ‘‘cascade ’’
Processus i (i=0 à n-1)
Début
P(mutex);
cpt=cpt +1;
Si cpt < n alors /* processus 0 à n-2 */
V(mutex); /* Sortir de la SC avant de se mettre en attente */
P(s); /* se mettre en attente */
V(s); /* Réveiller le processus suivant */
Sinon /* dernier processus*/
cpt=0;
V(mutex); /* Sortir de la SC */
V(s); /* réveiller le premier processus */
P(s); /* se mettre en attente */
/* le dernier processus est réveillé par l’avant dernier */
Finsi
Fin
- 31 -
6.3 Le modèle des lecteurs/rédacteurs
 Considérons deux classes de processus appelés : Lecteurs et
Rédacteurs. 
 Ces processus se partagent un fichier f.

 Les lecteurs peuvent seulement consulter le fichier,

 les rédacteurs peuvent seulement écrire sur le fichier.
 Les processus de ces deux classes doivent respecter les contraintes
suivantes:
• Plusieurs lecteurs peuvent lire simultanément le fichier.
• Un seul rédacteur à la fois peut écrire sur le fichier.
• Un lecteur et un rédacteur ne peuvent pas utiliser en même temps
le fichier. - 32 -
 Protocole utilisé par les processus
Lecteurs Rédacteurs
Demande de lecture Demande d'écriture
Lecture Ecriture
Fin de lecture (libérer le fichier) Fin d’écriture (libérer le fichier)

1. Les points de synchronisation

 Demande de lecture,
 Demande d’écriture,
 Fin de lecture (point non bloquant),
 fin d’écriture (point non bloquant).
2. Les conditions de franchissement
Soient
nl : nombre de lectures en cours,
ne : nombre d'écritures en cours (0 ou 1).
- Demande de lecture : si ne=0;
- Demande d'écriture : si ne=0 et nl=0; - 33 -
6.3.1 L’ordre d’accès au fichier f est quelconque
• Tous les processus (lecteurs et rédacteurs) ont la même priorité.

/* nl : le nombre de lecteurs utilisant le fichier f à un instant donné */

/* nl est une variable partagée par les lecteurs 
Utiliser un sémaphore d’exclusion mutuelle pour protéger nl */
Entier nl init 0;
Sémaphore mutex init 1;
/* Le fichier f est utilisé en exclusion mutuelle :
• Entre les deux classes de processus : lecteurs et rédacteurs;
• Entre les rédacteurs.
 Utiliser un sémaphore d’exclusion mutuelle pour le protéger */
Sémaphore sf init 1;

- 34 -
 Sémaphore sf init 1;

Entier nl init 0;
Sémaphore mutex init 1;
Lecteurs Rédacteurs
Début Début
/* demande de lecture */ /* demande d'écriture */
p(mutex); p(sf);
nl=nl+1;
si nl=1 alors p(sf); < écrire >
v(mutex);
< lire > /* fin d'écriture */
/* fin de lecture */ v(sf);
p(mutex); Fin;
nl=nl-1;
si nl=0 alors v(sf);
Remarque : Risque de
v(mutex);
privation pour les rédacteurs.
Fin; - 35 -
6.2.2 Ordre d’accès au fichier f selon FIFO
Sémaphore sf init 1;
Sémaphore sfifo init 1; /*sémaphore imposant l’ordre d’accès FIFO */
Entier nl init(0);
Sémaphore mutex init 1;
Lecteurs Rédacteurs
Début Début
/* demande de lecture */ /* demande d'écriture */
P(sfifo); P(sfifo);
p(mutex); p(sf);
nl=nl+1; V(sfifo);
si nl=1 alors p(sf);
v(mutex); < écrire >
V(sfifo);
< lire > /* fin d'écriture */
/* fin de lecture */ v(sf);
p(mutex); Fin;
nl=nl-1;
si nl=0 alors v(sf);
v(mutex);
Fin; - 36 -
6.4 Communication par variables communes

6.4.1 Définitions
• Soit T un tampon(buffer) accessible à l’ensemble des processus
voulant communiquer.
• On distingue deux classes de processus :
1. Producteur : processus désirant déposer de l’information dans
un tampon T
2. Consommateur : un processus désirant retirer de l’information
d’un tampon T.

- 37 -
6.4.2 Propriétés de la communication
La communication par variable(s) commune(s) est :
 Indirecte : le producteur et le consommateur ne s’adressent pas
l’un à l’autre.

 Asynchrone : il n’est pas nécessaire que le producteur et le

consommateur entrent en communication en même temps
(simultanément).
Il suffit, simplement, que le producteur ait déposé l’information
dans le tampon avant que le consommateur ne la retire.

 Multiple : plusieurs producteurs peuvent envoyer(déposer) des

messages à plusieurs consommateurs.

- 38 -
 Deux types de problèmes à traiter dans la communication par
variables communes :
1. La synchronisation des processus
· Un producteur ne peut déposer un message que s’il y a de la
place disponible dans le tampon(buffer).
· Un consommateur ne peut retirer un message que s’il y en a de
disponible.
· Les producteurs et les consommateurs ne peuvent accéder
simultanément au tampon que selon certaines règles assurant
l’intégrité de l’information.

2. La transmission
C'est le moyen par lequel l’information est communiquée :
Elle concerne la gestion du tampon T.

- 39 -
6.4.3 Schéma général du producteur-consommateur
· Le système de communication : il est composé
 du tampon : T,
 du mécanisme de synchronisation : Sémaphores ,
 des primitives de communication :
Envoyer(message) et Recevoir(message).
· Soient
 Un producteur désirant envoyer un message Mp dans un système
de communication et
 Un consommateur désirant retirer un message Mc de ce même
système de communication.

- 40 -
 Producteur Consommateur
Répéter Répéter
Produire(Mp); Recevoir(Mc);
Envoyer(Mp); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux;
Fin; Fin;
· Décomposant les procédures Envoyer et Recevoir en séparant le
problème de synchronisation et de celui de la transmission :

Producteur Consommateur
Procédure Envoyer(Mp) Procédure Recevoir(Mc)
Demande de dépôt ; Demande de retrait;
Déposer(Mp); Retirer(Mc);
Signaler dépôt; Signaler retrait;
Fin; Fin;
· Synchronisation : Demande de dépôt, Signaler dépôt,
Demande de retrait, signaler retrait.

· Transmission(ou gestion du tampon) : Déposer, Retirer.

- 41 -
6.4.4 Producteur-Consommateur avec un tampon à un seul
élément
· Un Tampon de taille égale à un élément ne peut contenir qu'une
seule information.
 Un producteur ne peut déposer une information dans le tampon
que si le consommateur a retiré la précédente.
 Un "Tampon à un seul élément" possède donc deux états :
plein et vide.
Remarque: Elément : variable simple ou structure.
 Producteur : Déposer si tampon est vide.
 Consommateur : Retirer si Tampon est plein.

· Réalisation avec les sémaphores

On associe deux sémaphores splein et svide au tampon T
initialisés respectivement à zéro et un.
- 42 -
 Producteur Consommateur
Procédure Envoyer(Mp) Procédure Recevoir(Mc)
Demande de dépôt ; Demande de retrait;
Déposer(Mp); Retirer(Mc);
Signaler dépôt; Signal er retrait;
Fin; T;
Tampon Fin;
Sémaphore splein init 0;
Sémaphore svide init 1;

Procédure Demande_de_dépôt Procédure Demande_de_retrait

P(svide); P(splein);
Fin; Fin;
Procédure Signaler_dépôt; Procédure Signaler_retrait;
V(splein);
Fin; V(svide);
Procédure Déposer(Mp); Procédure Retirer(Mc);
Fin;
T=Mp; Mc=T;
Fin; Fin; - 43 -
 Tampon T;

Sémaphore splein init 0;

Sémaphore svide init 1;
Producteur Consommateur
Début Début
Répéter Répéter
Produire(Mp) P(splein);
P(svide); Mc=T;
T=Mp; V(svide);
V(splein); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux;
Fin; Fin;

- 44 -
6.4.5 Producteur-Consommateur avec un tampon à n éléments
· Nombre fixe d’éléments du tampon égal à n.
· n est connu par le producteur et le consommateur.
· Un producteur ne peut déposer une information dans un élément
du tampon que si le consommateur a retiré la précédente.
· Les éléments du tampon sont consommés dans le même ordre que
leur production.
· Chaque élément du tampon à deux états : plein et vide.
· Producteur : Déposer s’il y a un élément vide dans le tampon.
· Consommateur : Retirer s’il y a un élément plein dans le
Tampon.

- 45 -
· Réalisation avec les sémaphores
a) Synchronisation
 On associe deux sémaphores splein et svide au tampon T.
 splein et svide initialisés respectivement à zéro et n. 
 Les procédures de synchronisation ne changent pas : elles sont les
mêmes , on ne change que l’initialisation du sémaphore svide.
Sémaphore splein init 0;
Sémaphore svide init n;
Producteur Consommateur
Début Début
Répéter Répéter
Produire(Mp) P(splein);
P(svide); Retirer(Mc)
Déposer(Mp) V(svide);
V(splein); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux; - 46 -
b) Gestion du tampon à n éléments
● Allocation statique du tampon.
● Le tampon sera géré de manière circulaire: On l'appelle tampon
circulaire ou buffer circulaire.
● Les éléments du tampon sont numérotés de 0 à n-1.
● Dans un tampon circulaire, on considère l'élément 0 comme le
successeur de l'élément n-1.

b.1) Un seul producteur et un seul consommateur

Pour parcourir le tampon, chaque classe de processus (producteur ou
consommateur) aura son propre pointeur:
 In : pointeur (ou index) utilisé par le producteur.
 Out : pointeur (ou index) utilisé par le consommateur.
 In et out sont deux variables locales respectivement au
producteur et consommateur et elles sont initialisées à 0(zéro).
- 47 -
 T: tableau[0..n-1] de tampon;
Sémaphore splein init 0;
Sémaphore svide init n;
Producteur Consommateur
Entier in init 0; Entier out init 0;
Début Début
Répéter Répéter
Produire(Mp) P(splein);
P(svide); Retirer(Mc)
Déposer(Mp) V(svide);
V(splein); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux;
Fin; Fin;
Déposer(Mp) Retirer(Mc)
T[in]:= Mp; Mc := T[out];
in :=(in +1) modulo n; out:=(out +1) modulo n;
- 48 -
Fin; Fin;
 T: tableau[0..n-1] de tampon;
Sémaphore splein init 0;
Sémaphore svide init n;
Producteur Consommateur
Entier in init(0); Entier out init(0);
Début Début
Répéter Répéter
Produire(Mp) P(splein);
P(svide); Mc := T[out];
T[in]:= Mp; out:=(out +1) modulo n;
in :=(in +1) modulo n; V(svide);
V(splein); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux;
Fin; Fin;

- 49 -
6.4.6 Plusieurs producteurs(P) et plusieurs consommateurs(C)
Ce cas pose un problème d'exclusion mutuelle au niveau de la gestion
du tampon (ou dans les procédures Déposer et Retirer):

 Exclusion mutuelle entre producteurs

Plusieurs producteurs ne doivent pas déposer en même temps de
l'information dans un même élément du tampon.

 Exclusion mutuelle entre Consommateurs

Plusieurs consommateurs ne doivent pas retirer (consommer) un
même message(un message n'est consommé qu'une seule fois par
un seul processus).

- 50 -
 Pour parcourir le tampon, chaque classe de processus (producteurs ou
consommateurs) aura son propre pointeur:
● In : pointeur (ou index) utilisé par les producteurs, c’est une
variable commune aux producteurs : ils doivent l'utiliser en
exclusion mutuelle.
● Out : pointeur (ou index) utilisé par les consommateurs. C’est une
variable commune aux consommateurs : ils doivent l'utiliser en
exclusion mutuelle.
● Les deux variables sont initialisées à 0(zéro).
● Pour protéger les variables communes in et out, on aura besoin de
deux sémaphores d'exclusion mutuelle sin et sout.
● sin et sout sont initialisés à 1.

- 51 -
Sémaphore sin init (1); Sémaphore sout init (1);

Déposer(Mp) Retirer(Mc)
p(sin); p(sout);
T[in]:= Mp; Mc := T[out];
in :=(in +1) modulo n; out:=(out +1) modulo n;
v(sin); v(sout);
Fin; Fin;

- 52 -
T: tableau[0..n-1] de tampon;
Sémaphore splein init 0;
Sémaphore svide init n;
Producteurs Consommateurs
Entier in init 0; Entier out init 0;
Sémaphore sin init 1; Sémaphore sout init 1;
Producteur i Consommateur i
Début Début
Répéter Répéter
Produire(Mp) P(splein);
P(svide); P(sout);
P(sin); Mc := T[out];
T[in]:= Mp; out:=(out +1) modulo n;
in :=(in +1) modulo n; V(sout);
V(sin); V(svide);
V(splein); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux; - 53 -
6.4.7 Producteur-Consommateur avec tampon à éléments alloués
· Les éléments du tampon sont alloués dynamiquement en faisant appel
à une fonction système(ou à un allocateur de mémoire).
· Le nombre d’éléments du tampon est variable il n’est pas connu à
l’avance.
· Dans ce cas, une partie du problème de synchronisation se trouve
reporter au niveau de "l'allocateur de la mémoire".
· L’allocateur de la mémoire a pour rôle :
 d'allouer aux producteurs qui lui demandent un élément de tampon,
 de libérer les éléments restitués par les consommateurs.

 Allocateur
Procédure allouer( élément);
Procédure restituer(élément);
Fin; - 54 -
 Réalisation des procédures au moyen des sémaphores
● Considérons deux primitives allouer(élément) et
restituer(élément) permettant respectivement l'allocation et la
libération d'un élément du tampon.
● On utilise un seul sémaphore splein initialisé à zéro.
● Ce sémaphore permet d'une part, au producteur de signaler le
dépôt de messages et d'autre part, il permet au consommateur de
vérifier la présence de message dans le tampon.
Tampon *T; /* le tampon est une liste */
splein: sémaphore init 0;
Procédure Demande_de_dépôt Procédure Demande_de_retrait
Allouer(élément); P(splein);
Fin; Fin;

Procédure Signaler_dépôt Signaler_dépôt

v(splein); Restituer(élément); - 55 -
Tampon *T;
Sémaphore splein init 0;
Producteur Consommateur
Début Début
Répéter Répéter
Produire(Mp) P(splein);
Allouer(élément); Retirer(T, Mc, élément);
Déposer(T, élément, MP); Restituer(élément);
V(splein); Consommer(Mc);
Jusqu’à faux; Jusqu’à faux;
Fin; Fin;

Remarque: allouer(élément) et restituer(élément) peuvent être

respectivement dans les procédures Déposer et Retirer

- 56 -