Synchronisation de processus M´ethodes de synchronisation Conclusion
Syst` emes d’Exploitation Cours 4/10 : Processus III
Nicolas Sabouret
Universit´ e Paris-Sud
Licence 3 - semestre S5
Synchronisation de processus M´ethodes de synchronisation Conclusion
Plan
1 Synchronisation de processus
2 M´ ethodes de synchronisation
3 Conclusion
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Plan
1 Synchronisation de processus Producteurs-consommateurs Section critique
2 M´ ethodes de synchronisation
3 Conclusion
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e
#define MAX 10 int taille = 0;
int [MAX] boite;
Producteur(s) void produire(char c){
while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e
taille Producteur(s) void produire(char c){
while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e
taille Producteur(s) void produire(char c){
while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e
taille Producteur(s) void produire(char c){
while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e
taille Producteur(s) void produire(char c){
while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
Quand on ne fait que produire, tout va bien
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
Quand on ne fait que produire, tout va bien 3
taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
Quand on ne fait que produire, tout va bien 3 5
taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
Quand on ne fait que produire, tout va bien 3 5 8
taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
Quand on ne fait que produire, tout va bien 3 5 8 2
taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
Quand on ne fait que produire, tout va bien 3 5 8 2 5
taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 2 5 taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 2 5 taille
Quand on ne fait que consommer, tout va bien
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 2
Quand on ne fait que consommer, tout va bien taille
c=5
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8
Quand on ne fait que consommer, tout va bien taille
c=2
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 taille
Mais quand on entrelace. . .
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 taille
Mais quand on entrelace. . .
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 taille
Mais quand on entrelace. . .
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 taille
Mais quand on entrelace. . .
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8 taille
Mais quand on entrelace. . .
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8
Mais quand on entrelace. . . taille
4
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Un exemple classique : producteurs et consommateurs
Espace partag´e Producteur(s)
void produire(char c){ while(taille==MAX)
; // attendre que la boite se vide boite[taille] = c;
taille++; // d´eposer et avancer }
une ligne de plus
Consommateur(s) char consommer() {
while(taille==0)
; // attendre qu’il y ait quelquechose taille--;
c = boite[taille]; // lire et retirer return c;
}
3 5 8
Mais quand on entrelace. . . taille
4
Synchronisation de processus M´ethodes 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´ ement (cf. cours 2)
ldr r0, @var add r0, #1 str r0, @var
Section critique
Lorsqu’il y a des variables partag´ ees, il existe des portions de code qu’on ne veut pas pouvoir interrompre.
→ Ce sont les sections critiques.
Synchronisation de processus M´ethodes 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´ ement (cf. cours 2)
ldr r0, @var add r0, #1 str r0, @var Section critique
Lorsqu’il y a des variables partag´ ees, il existe des portions de code qu’on ne veut pas pouvoir interrompre.
→ Ce sont les sections critiques.
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Exclusion mutuelle Principe
D´ eclarer une portion de code comme critique
L’OS garantit qu’au plus un seul processus prˆ et, en attente ou en ex´ ecution ou une seule thread est dans une section critique
→ les autres processus/threads sont mis en attente s’ils demandent ` a commencer une section critique
ils sont
r´ eveill´ es
par une interruption lorsque le processus finit sa S.C.
D´ efinition
On parle alors d’exclusion mutuelle.
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Exclusion mutuelle Principe
D´ eclarer une portion de code comme critique
L’OS garantit qu’au plus un seul processus prˆ et, en attente ou en ex´ ecution ou une seule thread est dans une section critique
→ les autres processus/threads sont mis en attente s’ils demandent ` a commencer une section critique
ils sont
r´ eveill´ es
par une interruption lorsque le processus finit sa S.C.
D´ efinition
On parle alors d’exclusion mutuelle.
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Exclusion mutuelle Principe
D´ eclarer une portion de code comme critique
L’OS garantit qu’au plus un seul processus prˆ et, en attente ou en ex´ ecution ou une seule thread est dans une section critique
→ les autres processus/threads sont mis en attente s’ils demandent ` a commencer une section critique
ils sont
r´ eveill´ es
par une interruption lorsque le processus finit sa S.C.
D´ efinition
On parle alors d’exclusion mutuelle.
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Propri´ et´ es
Exclusion Mutuelle
Si une thread effectue sa section critique, alors aucune autre thread ne peut entrer en section critique
D´ eroulement
Une thread qui souhaite entrer en section critique ne peut pas d´ ecider qui doit rentrer en section critique
Vivacit´ e (ou attente born´ ee)
Une thread qui souhaite entrer en section critique y rentre en temps born´ e
compt´ e en nombre de fois o` u elle passe son tour
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Propri´ et´ es
Exclusion Mutuelle
Si une thread effectue sa section critique, alors aucune autre thread ne peut entrer en section critique
D´ eroulement
Une thread qui souhaite entrer en section critique ne peut pas d´ ecider qui doit rentrer en section critique
Vivacit´ e (ou attente born´ ee)
Une thread qui souhaite entrer en section critique y rentre en temps born´ e
compt´ e en nombre de fois o` u elle passe son tour
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Propri´ et´ es
Exclusion Mutuelle
Si une thread effectue sa section critique, alors aucune autre thread ne peut entrer en section critique
D´ eroulement
Une thread qui souhaite entrer en section critique ne peut pas d´ ecider qui doit rentrer en section critique
Vivacit´ e (ou attente born´ ee)
Une thread qui souhaite entrer en section critique y rentre en temps born´ e
compt´ e en nombre de fois o` u elle passe son tour
Synchronisation de processus M´ethodes de synchronisation Conclusion Producteurs-consommateurs Section critique
Objectif
Synchronisation
D´ efinir des m´ ecanismes qui garantissent ces trois propri´ et´ es Exclusion mutuelle
D´ eroulement
Attente born´ ee
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Plan
1 Synchronisation de processus
2 M´ ethodes de synchronisation Mutex
Algorithme de Dekker S´ emaphores
Moniteurs
Synchronisation en Java
3 Conclusion
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Une solution pour 2 threads : le Mutex Principe
Un contrˆ oleur central Met en attente
Autorise les SC chacune ` a 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´ ero de la thread
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Une solution pour 2 threads : le Mutex Principe
Un contrˆ oleur central Met en attente
Autorise les SC chacune ` a 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´ ero de la thread
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores 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 t i invoque commencerSectionCritique(i) : V´ erifier que t 1−i n’est pas en SC (sinon, attendre) Noter que t i est en SC
Et lorsqu’elle invoque finirSectionCritique(i) :
Noter que t i n’est plus en SC
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores 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 t i invoque commencerSectionCritique(i) : V´ erifier que t 1−i n’est pas en SC (sinon, attendre) Noter que t i est en SC
Et lorsqu’elle invoque finirSectionCritique(i) :
Noter que t i n’est plus en SC
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores 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 t i invoque commencerSectionCritique(i) :
V´ erifier que t 1−i n’est pas en SC (sinon, attendre)
Noter que t i est en SC
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
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;
}
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
} t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T
Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une premi` ere impl´ ementation
Probl` eme
Ce code contient lui-mˆ eme des SC !
est SC = F F
void commencerSectionCritique(int id){ while (est SC[1-id])
;
est SC[id]=true;
}
t0
t0
t0
t1
t1
t1
t0
T
t1
T Les deux threads sont en SC!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation Principe
Mettre en attente la thread demandeuse si l’autre est d´ ej` a 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;
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; } t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T t0
t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une deuxi` eme impl´ ementation
Probl` eme
Risque d’interblocage !
est SC = F F
void commencerSectionCritique(int id){ est SC[id]=true;
while (est SC[1-id])
; }
t0
t0
t0
T
t1
t1
t1
T
t0 t1
Les deux threads sont en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Principe
Ajout de tours de priorit´ e
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) {
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC = F F tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1 tour = 1 t0
T T
t1
t1
tour = 0 tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC = F F tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1 tour = 1 t0
T T
t1
t1
tour = 0 tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC = F F tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0
t1
t0
t0
tour = 1 tour = 1 t0
T T
t1
t1
tour = 0 tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC = F F
tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0
t1
t0
t0
tour = 1
tour = 1 t0
T T
t1
t1
tour = 0 tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC =
F
F
tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0
t1
t0
t0
tour = 1
tour = 1 t0
T
T
t1
t1
tour = 0 tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC =
F
F
tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1
tour = 1 t0
T
T
t1
t1
tour = 0 tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC =
F
F
tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1 tour = 1
t0
T
T
t1
t1
tour = 0
tour = 0
t1
T T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC =
F F tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1 tour = 1
t0
T
T
t1
t1
tour = 0
tour = 0
t1
T
T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC =
F F tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1 tour = 1
t0
T
T
t1
t1
tour = 0
tour = 0
t1
T
T
t1
t0
Une seule thread est pass´ee, l’autre est en attente!
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Mutex : une troisi` eme impl´ ementation Pourquoi ¸ca marche ?
Respecte le principe de d´ eroulement :
Une thread qui veut entrer en SC ne peut pas d´ ecider qui entre en SC
Avant d’entrer en SC, je donne la main ` a l’autre (tour).
est SC =
F F tour = ?
void commencerSectionCritique(int id){ tour=1-id;
est SC[id]=true;
while (est SC[1-id] && tour==1-id)
; }
t0 t1
t0
t0
tour = 1 tour = 1 t0
T
T
t1
t1
tour = 0
tour = 0
t1
T
T
t1
t0
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Attente active
Probl` eme
Les processus font de l’attente active.
while (est SC[1-id] && tour==1-id)
;
→ Utilisation inutile du processeur
Solution
Appels syst` emes :
wait : l’OS met le processus en attente
notify : l’OS r´ eveille les processus en attente
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Attente active
Probl` eme
Les processus font de l’attente active.
while (est SC[1-id] && tour==1-id)
;
→ Utilisation inutile du processeur Solution
Appels syst` emes :
wait : l’OS met le processus en attente
notify : l’OS r´ eveille les processus en attente
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Attente active
Probl` eme
Les processus font de l’attente active.
while (est SC[1-id] && tour==1-id)
;
→ Utilisation inutile du processeur Solution
Appels syst` emes :
wait : l’OS met le processus en attente
notify : l’OS r´ eveille les processus en attente
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores 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();
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker
G´ en´ eralisation de Mutex ` a n processus 3 ´ etats pour chaque processus :
Hors section critique
En attente de d´ ecision pour rentrer en SC En section critique
Tours de priorit´ e et d´ eroulement :
Si celui dont c’est le tour n’est pas en demande, je peux demander ` a rentrer en SC
Sinon, je lui laisse la priorit´ e (il rentre en SC)
Exclusion mutuelle : On ne peut rentrer en SC que si personne
n’est en SC
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker II
public class MutexN implements Mutex {
public static final int RIEN, DEMANDE, TIENT;
3 ´ etats possibles pour chaque processus
int etat[] = new int[N] {RIEN,...,RIEN};
int tour = 0;
public void commencerSectionCritique(int id) {...}
public void finirSectionCritique(int id) {...}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker III
public void commencerSectionCritique(int id) {
int n; do {
etat[id] = DEMANDE;
while (tour!=id) d´ eroulement if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entr´ ee en SC
⇒ Jamais deux threads en DEMANDE en mˆ eme temps
n = 0; attendre la fin des autres SC
while ((n<N)&&((n==id)||(etat[n]!=TIENT))) n++;
} while (n<=N);
⇒Si une thread ´ etait en SC, je recommence depuis le d´ ebut
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker III
public void commencerSectionCritique(int id) {
int n; do {
etat[id] = DEMANDE;
while (tour!=id) d´ eroulement if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entr´ ee en SC
⇒ Jamais deux threads en DEMANDE en mˆ eme temps
n = 0; attendre la fin des autres SC
while ((n<N)&&((n==id)||(etat[n]!=TIENT))) n++;
} while (n<=N);
⇒Si une thread ´ etait en SC, je recommence depuis le d´ ebut
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker III
public void commencerSectionCritique(int id) { int n;
do {
etat[id] = DEMANDE;
while (tour!=id) d´ eroulement if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entr´ ee en SC
⇒ Jamais deux threads en DEMANDE en mˆ eme temps
n = 0; attendre la fin des autres SC
while ((n<N)&&((n==id)||(etat[n]!=TIENT))) n++;
} while (n<=N);
⇒Si une thread ´ etait en SC, je recommence depuis le d´ ebut
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker III
public void commencerSectionCritique(int id) { int n;
do {
etat[id] = DEMANDE;
while (tour!=id) d´ eroulement if (etat[tour] != DEMANDE)
tour=id;
etat[tour] = TIENT; entr´ ee en SC
⇒ Jamais deux threads en DEMANDE en mˆ eme temps
n = 0; attendre la fin des autres SC
while ((n<N)&&((n==id)||(etat[n]!=TIENT))) n++;
} while (n<=N);
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker IV
public void finirSectionCritique(int id) { etat[id] = RIEN;
}
Avantages
Respecte les 3 principes (d´ eroulement, exclusion et pas de famine) Inconv´ enients
N doit ˆ etre connu ` a l’avance !
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Algorithme de Dekker IV
public void finirSectionCritique(int id) { etat[id] = RIEN;
}
Avantages
Respecte les 3 principes (d´ eroulement, exclusion et pas de famine) Inconv´ enients
N doit ˆ etre connu ` a l’avance !
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore
E. Dijkstra, 1962-1963
Principe (simplifi´ e)
On d´ efinit un objet partag´ e (le s´ emaphore) : Qu’on peut acqu´ erir ;
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´ ee partagent un mˆ eme s´ emaphore
On acquiert le s´ emaphore avant d’entrer en SC ;
On relˆ ache le s´ emaphore en sortant de SC.
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore
E. Dijkstra, 1962-1963
Principe (simplifi´ e)
On d´ efinit un objet partag´ e (le s´ emaphore) : Qu’on peut acqu´ erir ;
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´ ee partagent un mˆ eme s´ emaphore
On acquiert le s´ emaphore avant d’entrer en SC ;
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : utilisation Utilisation du S´ emaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...
Difficult´ es
Vivacit´ e : on veut passer la main dans le bon ordre
→utilisation d’une file d’attente
acquerir et relacher doivent ˆ etre atomiques !
Elles sont elles-mˆ eme des SC pour l’´ etat du s´ emaphore et de la
file. . .
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : utilisation Utilisation du S´ emaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...
Difficult´ es
Vivacit´ e : on veut passer la main dans le bon ordre
→utilisation d’une file d’attente
acquerir et relacher doivent ˆ etre atomiques !
Elles sont elles-mˆ eme des SC pour l’´ etat du s´ emaphore et de la
file. . .
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : utilisation Utilisation du S´ emaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...
Difficult´ es
Vivacit´ e : on veut passer la main dans le bon ordre
→utilisation d’une file d’attente
acquerir et relacher doivent ˆ etre atomiques !
Elles sont elles-mˆ eme des SC pour l’´ etat du s´ emaphore et de la
file. . .
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : utilisation Utilisation du S´ emaphore
Semaphore s = new Semaphore();
... code non-critique ...
s.acquerir();
... code critique ...
s.liberer();
... code non-critique ...
Difficult´ es
Vivacit´ e : on veut passer la main dans le bon ordre
→utilisation d’une file d’attente
acquerir et relacher doivent ˆ etre atomiques !
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : impl´ ementation
Appels syst` emes
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
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : impl´ ementation
Appels syst` emes
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
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : code
p u b l i c c l a s s S e m a p h o r e {
int S = 0;
L i n k e d L i s t < Thread > f i l e = new L i n k e d L i s t < Thread > ( ) ; p u b l i c v o i d a c q u e r i r () {
d i s a b l e I n t e r r u p t ();
w h i l e ( S >0) {
f i l e . add ( T h r e a d . c u r r e n t T h r e a d ( ) ) ;
b l o c k( T h r e a d . c u r r e n t T h r e a d ( ) ) ; // a p p e l l e w a i t }
S ++;
e n a b l e I n t e r r u p t ();
} ...
}
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : code II
p u b l i c c l a s s S e m a p h o r e {
int S = 0;
L i n k e d L i s t < Thread > f i l e = new L i n k e d L i s t < Thread > ( ) ; ...
p u b l i c v o i d r e l a c h e r () { d i s a b l e I n t e r r u p t ();
S - -;
if ( S >0) {
T h r e a d t = f i l e . p o l l ();
w a k e u p ( t ); // a p p e l l e n o t i f y }
e n a b l e I n t e r r u p t ();
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
S´ emaphore : code II
p u b l i c c l a s s S e m a p h o r e {
int S = 0;
L i n k e d L i s t < Thread > f i l e = new L i n k e d L i s t < Thread > ( ) ; ...
}
Remarque
Le compteur S du s´ emaphore permet de contrˆ oler l’acc` es ` a plus
d’une seule ressource de mˆ eme type. . .
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Interblocages et s´ emaphores Interblocages
Les s´ emaphores sont des ressources partag´ ees
C’est l’utilisateur (le programmeur) qui d´ ecide quand sont utilis´ es les s´ emaphores
→ risque d’interblocage !
Thread 1 S1.acquerir();
S2.acquerir();
...
S1.relacher();
S2.relacher();
Thread 2 S2.acquerir();
S1.acquerir();
...
S2.relacher();
S1.relacher();
bloqu´e bloqu´e
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Interblocages et s´ emaphores Interblocages
Les s´ emaphores sont des ressources partag´ ees
C’est l’utilisateur (le programmeur) qui d´ ecide quand sont utilis´ es les s´ emaphores
→ risque d’interblocage !
Espace partag´e Semaphore S1, S2;
Thread 1 S1.acquerir();
S2.acquerir();
...
S1.relacher();
S2.relacher();
Thread 2 S2.acquerir();
S1.acquerir();
...
S2.relacher();
S1.relacher();
bloqu´e bloqu´e
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Interblocages et s´ emaphores Interblocages
Les s´ emaphores sont des ressources partag´ ees
C’est l’utilisateur (le programmeur) qui d´ ecide quand sont utilis´ es les s´ emaphores
→ risque d’interblocage !
Thread 1 S1.acquerir();
S2.acquerir();
...
S1.relacher();
S2.relacher();
Thread 2 S2.acquerir();
S1.acquerir();
...
S2.relacher();
S1.relacher();
bloqu´e bloqu´e
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Interblocages et s´ emaphores Interblocages
Les s´ emaphores sont des ressources partag´ ees
C’est l’utilisateur (le programmeur) qui d´ ecide quand sont utilis´ es les s´ emaphores
→ risque d’interblocage !
Espace partag´e Semaphore S1, S2;
Thread 1 S1.acquerir();
S2.acquerir();
...
S1.relacher();
S2.relacher();
Thread 2 S2.acquerir();
S1.acquerir();
...
S2.relacher();
S1.relacher();
bloqu´e
bloqu´e
Synchronisation de processus M´ethodes de synchronisation Conclusion Mutex Algorithme de Dekker S´emaphores Moniteurs Synchronisation en Java
Interblocages et s´ emaphores Interblocages
Les s´ emaphores sont des ressources partag´ ees
C’est l’utilisateur (le programmeur) qui d´ ecide quand sont utilis´ es les s´ emaphores
→ risque d’interblocage !
Thread 1 S1.acquerir();
S2.acquerir();
...
S1.relacher();
S2.relacher();
Thread 2 S2.acquerir();
S1.acquerir();
...
S2.relacher();
S1.relacher();
bloqu´e bloqu´e
