6. Les sémaphores (E.W. DIJIKSTRA - 1965) - Quand S.

count >= 0, le nombre de processus qui

peuvent exécuter wait (S) sans être bloqués
La résolution des problèmes liés à la
S.count.
programmation simultanée, notamment l’EM, a
considérablement progressé avec l’invention des - Quand S.count < 0, le nombre de processus dans
sémaphores. Un sémaphore est un puissant outil la file d’attente S.queue =|S.count|.
de synchronisation qui élimine l’attente active.
Un sémaphore est constitué de deux champs ; - wait(S) et signal(S) ne sont jamais exécutées
- Un compteur entier qui désigne le simultanément même dans un environnement
nombre d’autorisations d’accès à une SC. multiprocessus.
- Une file d’attente de processus ou de - L’EM se programme simplement en utilisant un
taches. sémaphore mutex initialisé à 1 quand un seul
struct semaphore { processus est autorisé en SC. Dans ce cas, la
int count ; structure du processus Pi est :
liste_processus queue ;
Processus Pi :
}
While (1){
Un sémaphore ne peut être manipulé que par SNC
deux opérations atomiques et mutuellement wait (mutex) ;
exclusives : SC
- P(S) ou down(S) ou wait(S) signal(mutex) ;
SNC
- V(S) ou up(S) ou signal(S)
}
Un sémaphore est initialisé à une valeur non Exercice d’application 1 : Réalisez une
négative avant son utilisation, le plus souvent synchronisation entre les processus P1 et P2 de
S.count=1. façon à ce que le bloc d’instructions S2 ne
s’exécute que si et seulement si le bloc S1 s’est
- L’opération wait(S) est exécutée par un déjà exécuté, et ceci en utilisant un sémaphore
processus avant son entrée en SC. Si la valeur de (Rendez-vous entre tâches):
S.count <0, le processus en question est bloqué
P1 : P2 :
et mis dans à la fin de la file d’attente de S. . .
. .
- L’opération signal(S) retire un processus de la . .
file d’attente (Généralement celui de tête de file) . S2
et le place dans la liste des processus S1 .
. .
« éligibles ». Description des opérations wait et
. .
signal : . .

void wait(S){ void signal(S){

S.count --; S.count ++;
If (S.count < 0) { If (S.count <= 0) {
(1) (2)
Bloquer ce processus ; Retirer un processus de S.queue;
Placer ce processus dans S.queue ; Placer ce processus dans S.queue ;
} }
} }

5
 Exemples de problèmes de synchronisation : Critique des sémaphores :
- Pour réaliser les sémaphores, on masque les
1- Le diner des philosophes (Voir en TD) interruptions dans un environnement
2- Le problème du coiffeur endormi (Voir en TD) multiprocessus ou on utilise l’instruction TAS :
Void wait (Sempahore S){ Void signal (Sempahore S){
3- Le problème des lecteurs-rédacteurs : Dans un Masquer les Interruptions ; Masquer les Interruptions ;
système de BDD, plusieurs processus veulent lire (1) (2)
ou écrire des informations. Plusieurs processus Démasquer les interruptions ; Démasquer les interruptions ;
peuvent lire en même temps, mais si un } }
processus est en train d’écrire, alors aucun autre
n’est autorisé à écrire ou même lire. Donc, l’attente active n’est pas complètement
éliminée, mais elle est réduite au minimum.
4- Le problème du producteur/consommateur :
un processus produit des informations qu’il - Les opérations wait et signal sont distribués
stocke dans un tampon (buffer) que d’autres dans plusieurs processus ce qui rend difficile la
processus viennent retirer. Le buffer est de taille programmation et la compréhension des
programmes. Il y’a aussi risque d’interblocage,
N.
exemple :
****************************************
semaphore S1=1, S2=1 ;
Exercice d’application 2 : Résoudre le problème P1 : P2 :
du producteur/consommateur : . .
. Wait(S2) ;
Processus consommateur : Wait(S1) ; .
Processus producteur :
. .
While (1){ While (1){ .
.
………………… ………………… . .
………………… ………………… Wait(S2) ; .
Produire_objet() ; Retirer_objet() ; . Wait(S1) ;
. .
………………… …………………
. .
………………… …………………
Déposer_objet() ; Consommer_objet() ;
- Il y’a aussi risque de violer l’accès en EM si on
………………… …………………
oublie un wait et un risque de blocage si on
………………… …………………
oublie un signal dans un programme.
} }
7. Les moniteurs (Hoare 1974, Brinch Hansen
1975)
Exercice d’application 3 : Résoudre le problème Un moniteur est une structure de variables et de
des lecteurs-rédacteurs : procédures pouvant être paramétrée et partagée
Processus lecteur : par plusieurs processus. Le type moniteur existe
Processus rédacteur :
While (1){ dans certains langages de programmation tel
While (1){
………………… ……………… que : Concurrent Pascal, Java et C#.
Ecrire() ; Lire() ; Le corps d’un moniteur est exécuté dès que le
………………… ………………… programme est lancé pour initialiser les variables
} } du moniteur.

6
- La seule manière pour un processus d’accéder à
une variable moniteur est d’appeler une
procédure moniteur.
- Si un processus est actif dans le moniteur et
qu’un autre demande à entrer dans le moniteur,
alors ce dernier est mis en attente.
- L’EM est assurée par le moniteur, l’utilisateur
n’est plus en charge de la programmer.
- La synchronisation des processus est réalisée via
l’utilisation de variables de condition (Qui sont
des variables booléennes) au moyen des
opérations :
- cwait(c) : Suspend le processus appelant (Le
mettre en attente de c, et en même temps,
autoriser un autre processus en attente du
moniteur à y entrer.
- csignal(c) : Débloque un processus en
attente de la condition c, Si plusieurs sont en
attente de c, alors un seul processus est
débloqué, et si aucun n’est en attente alors ne
rien faire.
Si P est actif dans le moniteur est qu’il invoque
csignal(c) et qu’il y’a un autre processus Q bloqué
associé à la condition c, alors il y’a deux
possibilités selon les langages :
a) Q est mis dans la file d’attente du
moniteur (signal and continue).
b) Q est activé dans le moniteur et c’est P
qui est mis dans la file d’attente du
moniteur (signal and wait).
Exemple d’application 4 : Résoudre le problème
du producteur/consommateur en utilisant un
moniteur.
Remarques:
1- Si un processus exécute un csignal sur une
condition c, et qu’aucun processus n’est en
attente, alors ce csignal est perdu.
2- Un processus qui exécute un cwait sur une
condition c est systématiquement suspendu.
7
7.1 Implémentation des moniteurs
On va considérer une possible implémentation du
moniteur en utilisant les sémaphores :
- Un sémaphore mutex est utilisé pour
assurer l’accès en EM au moniteur. La file
d’attente de mutex sera donc la file
d’attente du moniteur.
- Un sémaphore next est utilisé pour
mémoriser tout les processus qui ont
cédé le moniteur à un autre processus
dans le cas d’un appel à csignal. La file
d’attente de next sera la file d’attente
d’urgence. next_count est le compteur
du nombre de processus dans la file
d’attente de next.
- Pour chaque variable de condition x du
moniteur, on a :
• Un sémaphore x_sem initialisé à
0.
• Une file d’attente de x_sem.
• Un compteur x_count qui compte
le nombre de processus en
attente sur x.
Données partagées
x
y
next File d’attente
d’entrée
Opération N
Opération 1
Opérations
Schéma d’un moniteur
 Avant compilation Après compilation
monitor mon_moniteur semaphore mutex=1 ; //générés automatiquement
semaphore next=0 ;
int next_count0 ;
condition x; Semaphore x_sem=0;
Int x_count=0;
void F(…){ void F(…){
Corps de la fct; wait(mutex);
} Corps de la fct;
if (next_count >0)
signal(next);
else
signal(mutex);
}
cwait(x) x_count++;
if (next_count >0)
signal(next);
else
signal(mutex)
wait(x_sem);
x_count-- ;
csignal(x) if (x_count >0)
signal(x_sem);
next_count++;
wait(next);
next_count--;
}