Synchronisation de processus Méthodes de synchronisation Conclusion

Systèmes d’Exploitation
Cours 4/10 : Processus III

Nicolas Sabouret
Université Paris-Sud

Licence 3 - semestre S5

Info32b Systèmes d’Exploitation Nicolas Sabouret 1/37

 Synchronisation de processus Méthodes de synchronisation Conclusion

Plan

1 Synchronisation de processus

2 Méthodes de synchronisation

3 Conclusion

Info32b Systèmes d’Exploitation Nicolas Sabouret 2/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Plan

1 Synchronisation de processus
Producteurs-consommateurs
Section critique

2 Méthodes de synchronisation

3 Conclusion

Info32b Systèmes d’Exploitation Nicolas Sabouret 3/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Espace partagé

#define MAX 10
int taille = 0;
int [MAX] boite;

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s)

void produire(char c) {
while(taille==MAX)
; // attendre que la boite se vide
boite[taille] = c;
taille++; // déposer et avancer
}

Espace partagé

taille

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé

taille

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé

taille

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé

taille

Quand on ne fait que produire, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3

taille

Quand on ne fait que produire, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5

taille

Quand on ne fait que produire, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Quand on ne fait que produire, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8 2

taille

Quand on ne fait que produire, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8 2 5

taille

Quand on ne fait que produire, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8 2 5

taille

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8 2 5

taille

Quand on ne fait que consommer, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé c=5

3 5 8 2

taille

Quand on ne fait que consommer, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé c=2

3 5 8

taille

Quand on ne fait que consommer, tout va bien

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Un exemple classique : producteurs et consommateurs

Producteur(s) Consommateur(s)

void produire(char c) { char consommer() {

while(taille==MAX) while(taille==0)
; // attendre que la boite se vide ; // attendre qu’il y ait quelquechose
boite[taille] = c; taille--;
taille++; // déposer et avancer c = boite[taille]; // lire et retirer
} return c;
}

Espace partagé
3 5 4
8

taille

Mais quand on entrelace. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 4/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Entrelacement

Remarque
Les entrelacements se font au niveau du code binaire !
→ couper entre chaque instruction assembleur !
Exemple : incrément (cf. cours 2)
ldr r0, @var
add r0, #1
str r0, @var

Info32b Systèmes d’Exploitation Nicolas Sabouret 5/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Entrelacement

Remarque
Les entrelacements se font au niveau du code binaire !
→ couper entre chaque instruction assembleur !
Exemple : incrément (cf. cours 2)
ldr r0, @var
add r0, #1
str r0, @var

Section critique
Lorsqu’il y a des variables partagées, il existe des portions de code
qu’on ne veut pas pouvoir interrompre.
→ Ce sont les sections critiques.

Info32b Systèmes d’Exploitation Nicolas Sabouret 5/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Exclusion mutuelle

Principe
Déclarer une portion de code comme critique
L’OS garantit qu’au plus un seul processus prêt, en attente ou en
exécution ou une seule thread est dans une section critique

Info32b Systèmes d’Exploitation Nicolas Sabouret 6/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Exclusion mutuelle

Principe
Déclarer une portion de code comme critique
L’OS garantit qu’au plus un seul processus prêt, en attente ou en
exécution ou une seule thread est dans une section critique
→ les autres processus/threads sont mis en attente s’ils
demandent à commencer une section critique
ils sont  réveillés  par une interruption lorsque le processus finit sa S.C.

Info32b Systèmes d’Exploitation Nicolas Sabouret 6/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Exclusion mutuelle

Principe
Déclarer une portion de code comme critique
L’OS garantit qu’au plus un seul processus prêt, en attente ou en
exécution ou une seule thread est dans une section critique
→ les autres processus/threads sont mis en attente s’ils
demandent à commencer une section critique
ils sont  réveillés  par une interruption lorsque le processus finit sa S.C.

Définition
On parle alors d’exclusion mutuelle.

Info32b Systèmes d’Exploitation Nicolas Sabouret 6/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Propriétés

Exclusion Mutuelle
Si une thread effectue sa section critique, alors aucune autre
thread ne peut entrer en section critique

Info32b Systèmes d’Exploitation Nicolas Sabouret 7/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Propriétés

Exclusion Mutuelle
Si une thread effectue sa section critique, alors aucune autre
thread ne peut entrer en section critique

Déroulement
Une thread qui souhaite entrer en section critique ne peut pas
décider qui doit rentrer en section critique

Info32b Systèmes d’Exploitation Nicolas Sabouret 7/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Propriétés

Exclusion Mutuelle
Si une thread effectue sa section critique, alors aucune autre
thread ne peut entrer en section critique

Déroulement
Une thread qui souhaite entrer en section critique ne peut pas
décider qui doit rentrer en section critique

Vivacité (ou attente bornée)

Une thread qui souhaite entrer en section critique y rentre en
temps borné
compté en nombre de fois où elle passe son tour

Info32b Systèmes d’Exploitation Nicolas Sabouret 7/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Producteurs-consommateurs Section critique

Objectif

Synchronisation
Définir des mécanismes qui garantissent ces trois propriétés

Exclusion mutuelle

Déroulement

Attente bornée

Info32b Systèmes d’Exploitation Nicolas Sabouret 8/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Plan

1 Synchronisation de processus

2 Méthodes de synchronisation
Mutex
Algorithme de Dekker
Sémaphores
Moniteurs
Synchronisation en Java

3 Conclusion

Info32b Systèmes d’Exploitation Nicolas Sabouret 9/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Une solution pour 2 threads : le Mutex

Principe
Un contrôleur central
Met en attente
Autorise les SC chacune à son tour
→ respecte les 3 objectifs de la synchronisation

Info32b Systèmes d’Exploitation Nicolas Sabouret 10/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Une solution pour 2 threads : le Mutex

Principe
Un contrôleur central
Met en attente
Autorise les SC chacune à son tour
→ respecte les 3 objectifs de la synchronisation

Interface (en Java)

interface Mutex {
abstract void commencerSectionCritique(int id);
abstract void finirSectionCritique(int id);
id dans [0,1] est le numéro de la thread
}

Info32b Systèmes d’Exploitation Nicolas Sabouret 10/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Une solution pour 2 threads : le Mutex

Utilisation du Mutex
... code non-critique ...
commencerSectionCritique(my id);
... code critique ...
finirSectionCritique(my id);
... code non-critique ...

Info32b Systèmes d’Exploitation Nicolas Sabouret 11/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Une solution pour 2 threads : le Mutex

Utilisation du Mutex
... code non-critique ...
commencerSectionCritique(my id);
... code critique ...
finirSectionCritique(my id);
... code non-critique ...

Fonctionnement
Lorsque ti invoque commencerSectionCritique(i) :
Vérifier que t1−i n’est pas en SC (sinon, attendre)
Noter que ti est en SC

Info32b Systèmes d’Exploitation Nicolas Sabouret 11/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Une solution pour 2 threads : le Mutex

Utilisation du Mutex
... code non-critique ...
commencerSectionCritique(my id);
... code critique ...
finirSectionCritique(my id);
... code non-critique ...

Fonctionnement
Lorsque ti invoque commencerSectionCritique(i) :
Vérifier que t1−i n’est pas en SC (sinon, attendre)
Noter que ti est en SC
Et lorsqu’elle invoque finirSectionCritique(i) :
Noter que ti n’est plus en SC
Info32b Systèmes d’Exploitation Nicolas Sabouret 11/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

class Mutex1 implements Mutex {

boolean [] est SC = false,false;
pour noter qui est en SC
void commencerSectionCritique(int id) {
while (est SC[1-id])
; attendre. . .
est SC[id]=true;
}
void finirSectionCritique(int id) {
est SC[id]=false;
}
}

Info32b Systèmes d’Exploitation Nicolas Sabouret 12/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id])
;
est SC[id]=true;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

t0 void commencerSectionCritique(int id) {

while (est SC[1-id])
;
est SC[id]=true;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

t0 while (est SC[1-id])
;
est SC[id]=true;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id])
;
t0 est SC[id]=true;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) { t1

while (est SC[1-id])
;
t0 est SC[id]=true;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id]) t1
;
t0 est SC[id]=true;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id])
;
t0 est SC[id]=true; t1
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id])
;
est SC[id]=true; t1
t0 }

est SC = T
F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id])
;
est SC[id]=true; t1
}

est SC = T
F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une première implémentation

Problème
Ce code contient lui-même des SC !

void commencerSectionCritique(int id) {

while (est SC[1-id])
;
est SC[id]=true;
} t1

est SC = T
F T
F

Les deux threads sont en SC!

Info32b Systèmes d’Exploitation Nicolas Sabouret 13/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Principe
Mettre en attente la thread demandeuse si l’autre est déjà en SC

class Mutex1 implements Mutex {

boolean [] est SC = false,false;
void commencerSectionCritique(int id) {
est SC[id]=true; on commence par noter la SC !
while (est SC[1-id])
;
}
void finirSectionCritique(int id) {
est SC[id]=false;
}
}
Info32b Systèmes d’Exploitation Nicolas Sabouret 14/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

est SC[id]=true;
while (est SC[1-id])
;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

t0 void commencerSectionCritique(int id) {

est SC[id]=true;
while (est SC[1-id])
;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

t0 est SC[id]=true;
while (est SC[1-id])
;
}

est SC = F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

est SC[id]=true;
t0 while (est SC[1-id])
;
}

est SC = T
F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) { t1

est SC[id]=true;
t0 while (est SC[1-id])
;
}

est SC = T
F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

est SC[id]=true; t1
t0 while (est SC[1-id])
;
}

est SC = T
F F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

est SC[id]=true;
t0 while (est SC[1-id]) t1
;
}

est SC = T
F T
F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

est SC[id]=true;
while (est SC[1-id]) t1
t0 ;
}

est SC = T
F T
F

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une deuxième implémentation

Problème
Risque d’interblocage !

void commencerSectionCritique(int id) {

est SC[id]=true;
while (est SC[1-id])
t0 ; t1
}

est SC = T
F T
F

Les deux threads sont en attente!

Info32b Systèmes d’Exploitation Nicolas Sabouret 15/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Principe
Ajout de tours de priorité

class Mutex1 implements Mutex {

boolean [] est SC = false,false;
int tour = 0;
void commencerSectionCritique(int id) {
tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
;
}
void finirSectionCritique(int id) {
est SC[id]=false;
}
Info32b} Systèmes d’Exploitation Nicolas Sabouret 16/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) {

tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
;
}

est SC = F F

tour = ?

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

t0 void commencerSectionCritique(int id) { t1

tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
;
}

est SC = F F

tour = ?

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) { t1

t0 tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
;
}

est SC = F F

tour = ?

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) { t1

tour=1-id;
t0 est SC[id]=true;
while (est SC[1-id] && tour==1-id)
;
}

est SC = F F

tour = 1

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) { t1

tour=1-id;
est SC[id]=true;
t0 while (est SC[1-id] && tour==1-id)
;
}

est SC = T F

tour = 1

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) {

tour=1-id; t1
est SC[id]=true;
t0 while (est SC[1-id] && tour==1-id)
;
}

est SC = T F

tour = 1

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) {

tour=1-id;
est SC[id]=true; t1
t0 while (est SC[1-id] && tour==1-id)
;
}

est SC = T F

tour = 0

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) {

tour=1-id;
est SC[id]=true;
t0 while (est SC[1-id] && tour==1-id) t1
;
}

est SC = T T

tour = 0

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) {

tour=1-id;
est SC[id]=true;
t0 while (est SC[1-id] && tour==1-id)
; t1
}

est SC = T T

tour = 0

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Mutex : une troisième implémentation

Pourquoi ça marche ?

Respecte le principe de déroulement :
Une thread qui veut entrer en SC ne peut pas décider qui entre en SC

Avant d’entrer en SC, je donne la main à l’autre (tour).

void commencerSectionCritique(int id) {

tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; t1
t0 }

est SC = T T

tour = 0

Une seule thread est passée, l’autre est en attente!

Info32b Systèmes d’Exploitation Nicolas Sabouret 17/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Attente active

Problème
Les processus font de l’attente active.
while (est SC[1-id] && tour==1-id)
;
→ Utilisation inutile du processeur

Info32b Systèmes d’Exploitation Nicolas Sabouret 18/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Attente active

Problème
Les processus font de l’attente active.
while (est SC[1-id] && tour==1-id)
;
→ Utilisation inutile du processeur

Solution

Info32b Systèmes d’Exploitation Nicolas Sabouret 18/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Attente active

Problème
Les processus font de l’attente active.
while (est SC[1-id] && tour==1-id)
;
→ Utilisation inutile du processeur

Solution
Appels systèmes :
wait : l’OS met le processus en attente
notify : l’OS réveille les processus en attente

Info32b Systèmes d’Exploitation Nicolas Sabouret 18/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Attente active

Mutex
void commencerSectionCritique(int id) {
tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
wait();
}
void finirSectionCritique(int id) {
est SC[id]=false;
notify();
}

Info32b Systèmes d’Exploitation Nicolas Sabouret 19/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker

Généralisation de Mutex à n processus

3 états pour chaque processus :
Hors section critique
En attente de décision pour rentrer en SC
En section critique
Tours de priorité et déroulement :
Si celui dont c’est le tour n’est pas en demande, je peux
demander à rentrer en SC
Sinon, je lui laisse la priorité (il rentre en SC)
Exclusion mutuelle : On ne peut rentrer en SC que si personne
n’est en SC

Info32b Systèmes d’Exploitation Nicolas Sabouret 20/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker II

public class MutexN implements Mutex {

public static final int RIEN, DEMANDE, TIENT;
3 états possibles pour chaque processus
int etat[] = new int[N] {RIEN,...,RIEN};
int tour = 0;
public void commencerSectionCritique(int id) {...}
public void finirSectionCritique(int id) {...}

Info32b Systèmes d’Exploitation Nicolas Sabouret 21/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker III

public void commencerSectionCritique(int id) {

etat[id] = DEMANDE;

}
Info32b Systèmes d’Exploitation Nicolas Sabouret 22/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker III

public void commencerSectionCritique(int id) {

etat[id] = DEMANDE;
while (tour!=id) déroulement
if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entrée en SC
⇒ Jamais deux threads en DEMANDE en même temps

}
Info32b Systèmes d’Exploitation Nicolas Sabouret 22/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker III

public void commencerSectionCritique(int id) {
int n;

etat[id] = DEMANDE;
while (tour!=id) déroulement
if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entrée en SC
⇒ Jamais deux threads en DEMANDE en même temps
n = 0; attendre la fin des autres SC
while ((n<N)&&((n==id)||(etat[n]!=TIENT)))
n++;

}
Info32b Systèmes d’Exploitation Nicolas Sabouret 22/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker III

public void commencerSectionCritique(int id) {
int n;
do {
etat[id] = DEMANDE;
while (tour!=id) déroulement
if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entrée en SC
⇒ Jamais deux threads en DEMANDE en même temps
n = 0; attendre la fin des autres SC
while ((n<N)&&((n==id)||(etat[n]!=TIENT)))
n++;
} while (n<=N);
⇒Si une thread était en SC, je recommence depuis le début
}
Info32b Systèmes d’Exploitation Nicolas Sabouret 22/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker IV

public void finirSectionCritique(int id) {

etat[id] = RIEN;
}

Info32b Systèmes d’Exploitation Nicolas Sabouret 23/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Algorithme de Dekker IV

public void finirSectionCritique(int id) {

etat[id] = RIEN;
}

Avantages
Respecte les 3 principes (déroulement, exclusion et pas de famine)

Inconvénients
N doit être connu à l’avance !

Info32b Systèmes d’Exploitation Nicolas Sabouret 23/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore

E. Dijkstra, 1962-1963

Principe (simplifié)
On définit un objet partagé (le sémaphore) :
Qu’on peut acquérir ;
Qui met en attente ceux qui le demandent ;
Qui donne la main dans l’ordre des demandes.

Info32b Systèmes d’Exploitation Nicolas Sabouret 24/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore

E. Dijkstra, 1962-1963

Principe (simplifié)
On définit un objet partagé (le sémaphore) :
Qu’on peut acquérir ;
Qui met en attente ceux qui le demandent ;
Qui donne la main dans l’ordre des demandes.

Toutes les threads en concurrence sur une donnée partagent un

même sémaphore
On acquiert le sémaphore avant d’entrer en SC ;
On relâche le sémaphore en sortant de SC.

Info32b Systèmes d’Exploitation Nicolas Sabouret 24/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation
Utilisation du Sémaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...

Info32b Systèmes d’Exploitation Nicolas Sabouret 25/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation
Utilisation du Sémaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...

Difficultés
Vivacité : on veut passer la main dans le bon ordre

Info32b Systèmes d’Exploitation Nicolas Sabouret 25/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation
Utilisation du Sémaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...

Difficultés
Vivacité : on veut passer la main dans le bon ordre
→utilisation d’une file d’attente

Info32b Systèmes d’Exploitation Nicolas Sabouret 25/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation
Utilisation du Sémaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...

Difficultés
Vivacité : on veut passer la main dans le bon ordre
→utilisation d’une file d’attente
acquerir et relacher doivent être atomiques !
Elles sont elles-même des SC pour l’état du sémaphore et de la
file. . .
Info32b Systèmes d’Exploitation Nicolas Sabouret 25/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : implémentation

Appels systèmes
disableInterrupt et enableInterrupt
→ bloquer l’ordonnancement !
wait et notify
→ pour mettre la thread en attente

Info32b Systèmes d’Exploitation Nicolas Sabouret 26/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : implémentation

Appels systèmes
disableInterrupt et enableInterrupt
→ bloquer l’ordonnancement !
wait et notify
→ pour mettre la thread en attente

Principe
acquerir et relacher commencent chacune par un
disableInterrupt et se terminent par un enableInterrupt
Dans acquerir, si la file n’est pas vide, appeler wait
Dans relacher, appeler notify

Info32b Systèmes d’Exploitation Nicolas Sabouret 26/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : code

public class Semaphore {

int S = 0;
LinkedList < Thread > file = new LinkedList < Thread >();

public void acquerir () {

disableInterrupt ();
while (S >0) {
file . add ( Thread . currentThread ());
block ( Thread . currentThread ()); // appelle wait
}
S ++;
enableInterrupt ();
}

...
}

Info32b Systèmes d’Exploitation Nicolas Sabouret 27/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : code II
public class Semaphore {

int S = 0;
LinkedList < Thread > file = new LinkedList < Thread >();

...

public void relacher () {

disableInterrupt ();
S - -;
if (S >0) {
Thread t = file . poll ();
wakeup ( t ); // appelle notify
}
enableInterrupt ();
}

Info32b Systèmes d’Exploitation Nicolas Sabouret 28/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : code II

public class Semaphore {

int S = 0;
LinkedList < Thread > file = new LinkedList < Thread >();

...

Remarque
Le compteur S du sémaphore permet de contrôler l’accès à plus
d’une seule ressource de même type. . .

Info32b Systèmes d’Exploitation Nicolas Sabouret 29/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Interblocages et sémaphores

Interblocages
Les sémaphores sont des ressources partagées
C’est l’utilisateur (le programmeur) qui décide quand sont
utilisés les sémaphores

→ risque d’interblocage !

Thread 1 Thread 2
S1.acquerir(); S2.acquerir();
S2.acquerir(); S1.acquerir();
... ...
S1.relacher(); S2.relacher();
S2.relacher(); S1.relacher();

Espace partagé
Semaphore S1, S2;

Info32b Systèmes d’Exploitation Nicolas Sabouret 30/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Interblocages et sémaphores

Interblocages
Les sémaphores sont des ressources partagées
C’est l’utilisateur (le programmeur) qui décide quand sont
utilisés les sémaphores

→ risque d’interblocage !

Thread 1 Thread 2
S1.acquerir(); S2.acquerir();
S2.acquerir(); S1.acquerir();
... ...
S1.relacher(); S2.relacher();
S2.relacher(); S1.relacher();

Espace partagé
Semaphore S1, S2;

Info32b Systèmes d’Exploitation Nicolas Sabouret 30/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Interblocages et sémaphores

Interblocages
Les sémaphores sont des ressources partagées
C’est l’utilisateur (le programmeur) qui décide quand sont
utilisés les sémaphores

→ risque d’interblocage !

Thread 1 Thread 2
S1.acquerir(); S2.acquerir();
S2.acquerir(); S1.acquerir();
... ...
S1.relacher(); S2.relacher();
S2.relacher(); S1.relacher();

Espace partagé
Semaphore S1, S2;

Info32b Systèmes d’Exploitation Nicolas Sabouret 30/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Interblocages et sémaphores

Interblocages
Les sémaphores sont des ressources partagées
C’est l’utilisateur (le programmeur) qui décide quand sont
utilisés les sémaphores

→ risque d’interblocage !

Thread 1 Thread 2
S1.acquerir(); S2.acquerir();
bloqué S2.acquerir(); S1.acquerir();
... ...
S1.relacher(); S2.relacher();
S2.relacher(); S1.relacher();

Espace partagé
Semaphore S1, S2;

Info32b Systèmes d’Exploitation Nicolas Sabouret 30/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Interblocages et sémaphores

Interblocages
Les sémaphores sont des ressources partagées
C’est l’utilisateur (le programmeur) qui décide quand sont
utilisés les sémaphores

→ risque d’interblocage !

Thread 1 Thread 2
S1.acquerir(); S2.acquerir();
bloqué S2.acquerir(); bloqué S1.acquerir();
... ...
S1.relacher(); S2.relacher();
S2.relacher(); S1.relacher();

Espace partagé
Semaphore S1, S2;

Info32b Systèmes d’Exploitation Nicolas Sabouret 30/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Interblocages et sémaphores

Interblocages
Les sémaphores sont des ressources partagées
C’est l’utilisateur (le programmeur) qui décide quand sont
utilisés les sémaphores

→ risque d’interblocage !

Utilisation
Le sémaphore garantit l’exclusion mutuelle, la vivacité, la
non-famine
Le programmeur doit s’assurer qu’il ne crée pas d’interblocage

Info32b Systèmes d’Exploitation Nicolas Sabouret 30/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Moniteurs

Principe
Repose sur le principe de la programmation par objet.

Tout objet o peut être muni d’un moniteur.

On peut demander à attendre l’objet ;
On peut libérer l’objet.

Info32b Systèmes d’Exploitation Nicolas Sabouret 31/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Moniteurs

Principe
Repose sur le principe de la programmation par objet.

Tout objet o peut être muni d’un moniteur.

On peut demander à attendre l’objet ;
On peut libérer l’objet.

Exemple
Mot-clef synchronize en Java = moniteur simplifié

Info32b Systèmes d’Exploitation Nicolas Sabouret 31/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation

Principe
Application de la programmation orientée objets aux sémaphores :
un sémaphore pour chaque objet.

Info32b Systèmes d’Exploitation Nicolas Sabouret 32/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation

Principe
Application de la programmation orientée objets aux sémaphores :
un sémaphore pour chaque objet.

Utilisation d’un moniteur

Objet o;
... code non-critique ...
o.attendre(this);
... code critique ...
o.relacher(this);
... code non-critique ...

Info32b Systèmes d’Exploitation Nicolas Sabouret 32/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Sémaphore : utilisation

Principe
Application de la programmation orientée objets aux sémaphores :
un sémaphore pour chaque objet.

Nomenclature
Le moniteur désigne le mécanisme ;
Les objets associés aux sémaphores sont appelés des
conditions.

Info32b Systèmes d’Exploitation Nicolas Sabouret 32/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Moniteurs en Java

Principe
1 moniteur par objet
attente = bloc synchronize(objet) {
relâcher = fin du bloc synchronize }

Info32b Systèmes d’Exploitation Nicolas Sabouret 33/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Moniteurs en Java

Principe
1 moniteur par objet
attente = bloc synchronize(objet) {
relâcher = fin du bloc synchronize }

Méthodes
Possibilité de déclarer tout une méthode synchronized
Équivalent à un bloc synchronized(this) englobant tout le
corps de la fonction

Info32b Systèmes d’Exploitation Nicolas Sabouret 33/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Moniteurs en Java

Principe
1 moniteur par objet
attente = bloc synchronize(objet) {
relâcher = fin du bloc synchronize }

Méthodes
Possibilité de déclarer tout une méthode synchronized
Équivalent à un bloc synchronized(this) englobant tout le
corps de la fonction

Conséquences
Une seule thread à la fois dans un bloc synchronize pour un
objet donné
Info32b Systèmes d’Exploitation Nicolas Sabouret 33/37
 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Moniteurs en Java

Attention
Une thread qui possède un verrou peut rentrer dans n’importe
quelle méthode (verrou récursif)
Une thread peut verrouiller plusieurs objets (risque
d’interblocage)
Tout bloc non synchronized peut être appelé par n’importe
qui n’importe quand
Méthodes wait et notify de la classe Object appelables dans
un bloc synchronized (uniquement)

Info32b Systèmes d’Exploitation Nicolas Sabouret 34/37

 Synchronisation de processus Méthodes de synchronisation Conclusion
Mutex Algorithme de Dekker Sémaphores Moniteurs Synchronisation en Java

Démo

Info32b Systèmes d’Exploitation Nicolas Sabouret 35/37

 Synchronisation de processus Méthodes de synchronisation Conclusion

Plan

1 Synchronisation de processus

2 Méthodes de synchronisation

3 Conclusion

Info32b Systèmes d’Exploitation Nicolas Sabouret 36/37

 Synchronisation de processus Méthodes de synchronisation Conclusion

Synthèse

Problème d’utilisation des ressources partagées

Exemple classique : producteurs/consommateurs
Notion de section critique
Propriétés d’exclusion mutuelle, de déroulement et de vivacité
Problème de l’attente active : wait et notify
Mutex pour 2 ou N threads
Sémaphores
Moniteurs

Info32b Systèmes d’Exploitation Nicolas Sabouret 37/37