Cours 2: Exclusion Mutuelle entre

processus (lourds, ou lgers -threads)

Concurrence entre processus &

Problme dExclusion Mutuelle
1.
2.
3.

Introduction
Solutions avec attente active, dites Sans Arbitrage
Solutions avec blocage (attente passive), dites Avec
Arbitrage

1 Introduction

Expos du problme

Les entits (processus ou threads) en cours dexcution
sont gnralement :

Indpendantes et Asynchrones

Leur fonctionnement ne dpend pas a priori du travail ralis par
les autres entits

Elles peuvent a priori progresser leur rythme sans se soucier les
unes des autres : elles pourraient sexcuter en parallle, mme si
sur un seul CPU, on parlera de pseudo paralllisme

Pourtant, ces entits peuvent tre en concurrence

pour lutilisation de ressources

& Avoir besoin de se synchroniser et communiquer
(chapitres suivants) : dans ce cas, elles seront au
contraire dpendantes les unes des autres

1 Introduction

La notion de Concurrence

Dfinition :
Rivalit dintrt entre entits provoquant une comptition

Ressources physiques [ partager car en nombre insuffisant]

Processeur, disque, imprimante,

Ressources logiques [leur rle est de conserver ou mmoriser

des donnes, un tat commun]

Donnes globales du Systme dExploitation

Zones de mmoire partage

Fichiers dune base de donnes

1 Introduction

Rle des solutions proposes

But: Contrler la concurrence

Organiser la comptition:

Fournir des services de synchronisation indirecte par
exclusion mutuelle : Arbitrage , rle du systme

Ou au contraire, inclure la partie contrle de concurrence
au sein des programmes : sans arbitrage par le systme

Coordonner lutilisation des ressources:

Empcher ou rparer des blocages, garantir lquit ou
absence de famine

1 Introduction

Illustrations (1/3)

Exemple 1 :

Pour tout i, Pi ne doit pas imprimer tant que une
autre impression est en cours !
Processus P

Processus Q

imprimer(ligne l1)

imprimer(ligne k1)

imprimer(ligne l2)

imprimer(ligne k2)

1 Introduction

Illustrations (2/3)

Exemple 2 :

Une instruction assembleur est indivisible, mais
pas une suite dinstructions
variable commune : n (compte bancaire)
P(Virement nP)
nP)

n:=n+nP
n:=n+nP

Q(Virement nQ)
nQ)

n:=n+nQ
n:=n+nQ

Actions_P :
1. load Reg_P, n
2. add Reg_P, nP
3. store Reg_P, n

Actions_Q :
1. load Reg_Q, n
2. add Reg_Q, nQ
3. store Reg_Q, n

1 Introduction

Illustrations (3/3)

Exemple 2 (suite)

Entrelacements possibles lors de lexcution des actions Action_P et

Action_Q
Actions_P :
1.
load Reg_P, n
2.
add Reg_P, nP
3.
store Reg_P, n

Actions_Q :
1. load Reg_Q, n
2. add Reg_Q, nQ
3. store Reg_Q, n

1, 2, 3, 1, 2
2, 3
3
n=n+nP
+nQ
n=n+nP+
1, 2
2, 3
3, 1, 2, 3
OK !
1, 1, 2, 2, 3, 3
1, 2, 1, 2
2, 3, 3
n=n+nQ
n=n+nQ
1, 1, 2
2, 2, 3, 3
PBM : nP perdu !
1, 2, 1, 3, 2, 3
3
1, 1, 2, 3, 2, 3
3
1, 1, 2, 2, 3, 3
1, 2
2, 1, 2, 3, 3
n=n+nP
n=n+nP
1, 1, 2, 2, 3
3, 3
PBM : nQ perdu !
1, 2
2, 1, 3, 2, 3
1, 1, 2, 3
3, 2, 3 Il faut que : 3 pr
prcde (<) 1
1 ou 3
3 < 1

Donc, que Actions_P < Actions_Q ou Actions_Q < Actions_P

1 Introduction

Solution au Problme

Imposer que les sections critiques soient excutes
de manire non entrelace

pour garantir une utilisation correcte des ressources

Limprimante dans lexemple 1

La variable n dans lexemple 2

On dit aussi quune section critique doit tre

indivisible, atomique

Mais cest un abus de langage , car on ne veut pas
forcement excuter une section critique comme si ctait une
(mga)-instruction => mauvaises performances (car un bon
ordonnancement entre processus ncessite un partage plus fin
du temps daccs CPU)

1 Introduction

Section Critique et Exclusion Mutuelle

Section (de code) Critique : code devant pouvoir faire
lhypothse quil utilise la ressource de manire
exclusive

Si aucune prcaution particulire nest prise, rien nempche
plusieurs entits la fois dutiliser la ressource
Empcher les entits qui sont en comptition (pour une
ressource donne) dentrer simultanment dans leur section
[de code] critique.
Les sections critiques sexcutent donc en exclusion
mutuelle

1 Introduction

Classes de solutions au problme de lEM

2 grandes classes de solutions envisageables :

Solution Ad hoc, sans arbitrage, intgre aux codes programmeur

Allocation de ressource incorporant appel implicite un arbitre

Les 2 classes exigent lajout de code de protection autour de la

section critique:
Protocole d
dentr
entre en
section critique
<section de code critique>
Protocole de sortie de
section critique

Demande de la ressource
<section de code critique>
Lib
Libration de la ressource

Remarque : dans certains cas (si ressource=CPU) la demande dallocation de

la ressource nest pas explicite

1 Introduction

Proprits attendues dune solution

1.

(1/2)

Exclusion mutuelle
A tout instant, un processus au plus excute des instructions de sa
section critique

2.

Absence de blocage (permanent)

Si plusieurs processus attendent pour entrer en SC, et si aucun
processus nest dj en SC, alors un des processus qui attend doit
pouvoir entrer en SC au bout dun temps fini

3.

Condition de progression (cad. blocage que temporaire)

Un processus qui se trouve hors de sa SC et hors du protocole
contrlant laccs la SC ne doit pas empcher un autre processus
dentrer dans sa SC : un processus ne doit pas ralentir un autre

1. Introduction

Proprits attendues dune solution

4.

(2/2)

Equit (Absence de famine)

Un processus qui est bloqu lentre de la section critique
nattendra pas indfiniment son tour
Pour un processus qui veut entrer en SC, il existe une borne
suprieure au nombre de fois o dautres entits excuteront leur SC
avant lui
(La valeur de la borne permet de mesurer quel point une solution est
quitable)

5.

Code identique (proprit souhaitable par souci de simplicit)

Le code qui protge la section critique (protocole dentre et
protocole de sortie) est le mme pour toutes les entits

Concurrence entre processus &

Exclusion Mutuelle
1.
2.
3.

Introduction
Solutions avec attente active, dites Sans Arbitrage
Solutions avec blocage (attente passive), dites Avec
Arbitrage

2 Solutions avec attente active

Protocoles de gestion de Section Critique

Principe :
Une entit dsirant entrer en SC attend de faon active quune
condition soit vrifie (ici, aucune autre entit en SC)
Tant que (condition indique SC non libre) Faire
rien ou sleep(court
sleep(court d
dlai)
Fintantque
<section de code critique>
Modifier condition pour refl
reflter SC libre
<section de code non critique>

Problme : Consommation inutile de temps CPU

2 Solutions avec attente active

Exemple simple et incorrect

Libre: variable commune, initialement Vraie

P1

P2

Tant que (!Libre) Faire

sleep(d
lai);
sleep(d
Fintantque
Libre=faux;
<section critique>
Libre:=vrai;

Tant que (!Libre) Faire

sleep(d
lai);
sleep(d
Fintantque
Libre:=faux;
<section critique>
Libre:=vrai;

2 Solutions avec attente active

Solutions dites logicielles (1)

Algorithme 1 : une solution nave
Tour : variable commune, initialement =1 (par ex)
(quand tour =i, Pi peut entrer en SC)
P1

P2

Rpter
Tant que (Tour = 2) Faire
sleep(d
lai);
sleep(d
Fintantque
<section critique>
Tour :=2
Jusqu
Jusqu faux

Rpter
Tant que (Tour = 1) Faire
sleep(d
lai);
sleep(d
Fintantque
<section critique>
Tour :=1
Jusqu
Jusqu faux

2 Solutions avec attente active

Solutions dites logicielles (2)

Analyse algorithme 1

Exclusion mutuelle : Ok

Absence de blocage : Ok

Condition de progression : NON

Lorsque Pi quitte sa SC, Tour:=j

Pour entrer nouveau en SC, Pi doit attendre que Pj
excute sa SC (stricte alternance des 2)

Absence de famine : Ok

Code identique : NON

Solutions dites logicielles (3)

[Peterson 1981]

Correct, gnralisable N processus (mais N
fix lavance)

P1

Tour : variable commune, initialement =1 (par ex)

Drapeau1, Drapeau2, initialement = faux
(quand tour =i, Pi peut entrer en SC)
P2

Drapeau1 = vrai ; Tour:=2

Tour:=2
Tant que (Drapeau2 ET Tour=2
Tour=2)
Faire sleep(d
lai);
sleep(d
Fintantque
<section critique>
Drapeau1 := faux

Drapeau2 = vrai ; Tour:=1

Tour:=1
Tant que (Drapeau1 ET Tour=1
Tour=1)
Faire sleep(d
lai);
sleep(d
Fintantque
<section critique>
Drapeau2 := faux

2 Solutions avec attente active

Solutions dites logicielles (4)

Analyse algorithme de Peterson

Exclusion mutuelle
preuve par labsurde : P1 ET P2 en SC

P1 en SC =>
Drapeau2=faux OU Tour =1

P1 en SC =>
Drapeau1 = vrai

ET

ET

P2 en SC =>
Drapeau1=faux OU Tour =2

P2 en SC =>
Drapeau2 = vrai

Donc Tour = 1 ET Tour = 2 => Impossible !

10

2 Solutions avec attente active

Solutions dites logicielles (5)

Analyse algorithme Peterson (suite)

Absence de blocage
Preuve par labsurde : supposons P1 et P2 sont incapables de
terminer leur protocole dentre en SC (cad bloqus
simultanment) dans Tant que

Drapeau2=vrai
ET Tour = 2

ET

Drapeau1= vrai
ET Tour = 1

Donc Tour = 1 ET Tour = 2 => Impossible !

2 Solutions avec attente active

Solutions dites logicielles (6)

Analyse algorithme Peterson (suite)

Condition de progression
Preuve par labsurde : supposons P2 dans sa section restante (hors
SC) ET P1 incapable de finir son protocole dentre, cad :

Drapeau2 = faux
Drapeau2=vrai ET Tour = 2

Donc

Drapeau2 = faux ET
Drapeau2 = vrai

=> Impossible !

11

2 Solutions avec attente active

Solutions dites logicielles (7)

Analyse algorithme Peterson (suite)

Absence de famine
Preuve directe : Supposons que P2 attend alors que P1 est
dans sa SC.
Drapeau2 = vrai

ET

P2 attend : en effet

Drapeau1= vrai ET Tour = 1

Maintenant, P1 quitte sa SC, puis excute nouveau le
protocole dentre en SC :
Drapeau2=vrai ET Tour = 2

P1 NE peut PAS entrer nouveau en SC. P2 POURRA entrer ds

son prochain tour de boucle (test de la condition).

2 Solutions avec attente active

Solutions de niveau Matriel

Masquage des niveaux dinterruption

Protocole dentre en SC : masquer les interruptions

La SC ne peut tre interrompue car les changements de
contexte sont impossibles

Protocole de sortie de SC : dmasquer les interruptions

Remarques :

Solution uniquement utilisable dans (par) lexcutif

A utiliser pour des SC trs courtes, car plus de paralllisme

Ne convient pas pour les machines multi-processeurs mmoire
partage (car chaque processeur gre ses propres interruptions)

Analyse:

Absence de blocage : OK, lordonnanceur du CPU finit par donner
la main un processus voulant rentrer dans sa SC

Condition de progression : OK

Absence de famine : OK si lordonnanceur lassure (normalement
oui !)

Code identique : OK

12

2 Solutions avec attente active

Solutions de niveau Matriel (2)

Utilisation dune instruction CPU : Test-And-Set (TAS)

prev = TAS(var) excute de faon rellement indivisible :

1.
2.

Intrt : deux (plusieurs) entits ne peuvent pas (avoir

limpression de) faire passer la variable de la valeur 0 la valeur
1 en mme temps :

1.
2.

prev = var
var = 1

Celui qui fait passer la variable de la valeur 0 la valeur 1 le sait (en

sortie, prev = 0)
Celui qui NE peut PAS faire passer la variable de la valeur 0 la
valeur 1 le sait aussi (en sortie, prev = 1)

Celui qui gagne est celui parvient faire passer la valeur de la

variable de 0 a 1 (celui qui rcupre prev = 0).

2 Solutions avec attente active

Solutions de niveau Materiel (3)

Utilisation de Test-and-set en attente active pour lexclusion
mutuelle
verrou: variable commune, initialement 0 (
vrouill
rouill )
( dv

P1

P2

prev : var locale

prev : var locale

prev = TAS(verrou
);
TAS(verrou);
Tant que (prev = 1)
Faire
/* sleep(d
lai); */
sleep(d
prev = TAS(verrou
);
TAS(verrou);
Fintantque
<section critique>
verrou = 0;

prev = TAS(verrou
);
TAS(verrou);
Tant que (prev = 1)
Faire
/* sleep(d
lai); */
sleep(d
prev = TAS(verrou
);
TAS(verrou);
Fintantque
<section critique>
verrou = 0;

13

2 Solutions avec attente active

Solutions de niveau Matriel (4)

Analyse de la solution base sur TAS :

Exclusion mutuelle : Ok
Absence de blocage : Ok
Condition de progression : Ok
Absence de famine :

Ok si lordonnanceur lassure (cad si nactive pas Pi
ternellement),

sinon, cest NON

si Pi quitte sa SC, garde le CPU et se prsente nouveau
lentre de la SC : verrou toujours 0, donc Pi entre
nouveau (remarque applicable aussi pour sol.
Masquage )

Code identique : Ok

2 Solutions avec attente active

Solutions de niveau Matriel (5)

Remarques sur solution avec TAS :

Sur une machine multi-processeurs mmoire partage,
plusieurs excutions de TAS peuvent sentrelacer

=> LExclusion Mutuelle nest plus garantie

Remde (matriel aussi) : verrouillage du bus mmoire pendant
linstruction TAS

Le mcanisme pour rsoudre lexclusion mutuelle (ici TAS)

est lui-mme une section critique, qui doit parfois tre
protge un niveau plus bas (ici verrouillage bus mmoire)

En fait, ce principe est gnralisable pour toute solution au
problme de lexclusion mutuelle (voir TD)

14

2 Solutions avec attente active

Bilan

Solutions avec attente active gourmandes en
temps CPU

Solutions ad-hoc:

programmation plus technique, source derreurs si
on oublie de librer la SC

Lquit dpend souvent entirement de

lordonnanceur, or il nest pas explicitement
sollicit

Un processus peut garder le CPU suffisamment
longtemps et faire ainsi plusieurs entres en SC
sans que ceux qui attendent puissent avoir leur
tour

Bilan sur Exc. Mut par Attente active

test dois-je attendre ? est excut en boucle

Ne provoque pas de commutation de contexte volontaire ( je
rends la main ) de la part du processus qui attend

Sauf que si on veut quun processus fasse progresser les choses et
donc que lattente se termine, il faut bien quil ait la main,
donc, que le SE commute vers lui !

Utilise / gaspille du temps CPU (jusqu puisement du quantum
de temps)

A utiliser de prfrence pour des attentes quon sait tre courtes
car la condition va changer rapidement

Ex: si la section de code critique est toujours trs courte

Ex: si lvnement qui va rendre la condition vraie arrive trs
frquemment

et si ce changement peut arriver en parallle de lattente

Ex: cas dune machine multi-CPUs, ce qui est courant

Ex: vnement provoqu par un autre lment que le CPU (ex, fin
dE/S disque)

15

Concurrence entre processus &

Exclusion Mutuelle
1.
2.
3.

Introduction
Solutions avec attente active, dites Sans Arbitrage
Solutions avec blocage (attente passive), dites
Avec Arbitrage

3 Solutions avec blocage

Gnralits

Les solutions avec attente active sont gourmandes en
temps CPU

Lorsque lattente est longue

Lorsque plusieurs (nombreux) concurrents attendent

Les processus puisent leur quantum dans lattente

active

16

3 Solutions avec blocage

Principe de fonctionnement
Rpter

1 EstEst-ce que je peux entrer en SC (je demande ceci larbitre) ?

2 Si NON alors je me bloque
<section critique>
Je relche la SC (en le disant larbitre), et la question se pose :
EstEst-ce qu
quun processus est bloqu
bloqu ?
Si OUI alors le r
rveiller (ou Ordonner un r
rveil)
Jusqu
Jusqu faux

Attention au problme des Ordres de Rveil Perdus (lost wake-up)

(revu en TD):

Au moment dexcuter 2, le rsultat de 1 nest peut-tre plus
valide !!

La seule solution pour viter le problme du rveil perdu :

Raliser de manire indivisible le test permettant de dcider du blocage et le

blocage lui-mme (cad le protocole dentre)

3 Solutions avec blocage

Principe de fonctionnement (2)

Le protocole de sortie doit aussi tre ralis de manire
indivisible
Modification de ltat doccupation de la SC et rveil dun processus
doivent se raliser de manire indivisible

Sinon : risque davoir plus de 1 processus en SC !

Plusieurs mises en uvre de ce principe avec blocage

Mais toujours en troite relation avec le support dexcution
des entits

processus : Noyau du systme

threads : Noyau librairie threads (ou Noyau du systme si threads
gres par lui)

17

3 Solutions avec blocage

Smaphores [Dijkstra, 1965]

Outil gnral, pouvant servir rguler dautres interactions de
nature Synchronisation entre entits :
permettre un nombre born (ventuellement plus grand que 1)
dentits dentrer en section critique

Attendre quun nombre minimal dentits soient bloques avant que
lune delles puisse continuer (rendez-vous)

Description

Smaphore = type abstrait

structure de donnes (compteur + file dattente dentits)

interface (oprations, dont initialisation, sur la structure de donnes)

3 Solutions avec blocage

Smaphores (2)

structure de donnes :

Val : entier sign, indique un nombre de permissions

File : file de (contexte ou descripteur) entits

oprations :

init(s:smaphore, val_init : entier)

s.Val = val_init

P(s: smaphore) indivisible

Prendre le smaphore

V(s: smaphore) indivisible

Relcher le smaphore

Remarque : P vient du hollandais Proberen (essayer) et V

vient de Verhogen (librer)

18

3 Solutions avec blocage

Smaphores: opration P
Op
Opration P(s:semaphore
P(s:semaphore))
Si (s.Val
(s.Val <=0)
Alors //ranger le descripteur du processus dans s.File
ajouter (s.File
(s.File,, descripteur processus courant);
//mettre le processus dans l
tat bloqu
ltat
bloqu
descripteur courant . Etat = BLOQU
BLOQU
//choisir un nouveau processus rendre actif
faire appel lordonnanceur pour qu
quil choisisse
Sinon s.Val := s.Val 1;
FinSi

3 Solutions avec blocage

Smaphores: opration V
Op
Opration V(s:semaphore
V(s:semaphore))
Si (s.File
(s.File non vide)
Alors //retirer
//retirer de s.File le descripteur d
dun processus
P= retirer (s.File
(s.File))
// mettre ce processus dans l
tat prt
ltat
P. etat = PR
PRT
Sinon s.Val := s.Val + 1;
FinSi

19

3 Solutions avec blocage

Smaphores : utilisation pour rsoudre EM

Exclusion mutuelle = 1 seule permission accorde
Variable commune : Mutex : smaphore
Avant de commencer, une entit excute INIT(Mutex,1)

Mutex.Val =1 => SC libre

Mutex.Val=0 => SC occupe

Pi pour tout i :
Rpter
<hors section critique
critique>
P(Mutex
P(Mutex))
<section critique>
V(Mutex
V(Mutex))
<hors section critique
critique>
Jusqu
Jusqu

3 Solutions avec blocage

Analyse solution par smaphores

Exclusion mutuelle : Ok par dfinition de P et de
INIT(Mutex,1)

Absence de blocage : Ok par indivisibilit de P

Condition de progression : Ok par dfinition de V

Absence de famine : dpend de lordre de retrait de
la file du smaphore. Si lordre est FIFO = Ok

Code identique : Ok

Et cest efficace ! Pendant lattente des processus, ceux

qui ne sont pas bloqus peuvent utiliser le CPU

20

3 Solutions avec blocage

Moniteurs
[Hoare, 1974 Brinch Hansen, 1975]

Motivation : cette poque, mergence du concept de type
abstrait: structure de donne cache manipule par des
oprations de spcification connue (prcurseur dobjet!)

Do lide vidente : intgrer les protocoles dentre et de
sortie de SC au dbut et la fin des oprations spcifies comme
devant sexcuter en exclusion mutuelle

Cest le compilateur qui rajoute les instructions du protocole
dentre et de sortie, souvent base de smaphores.

Utilisation pour lexclusion mutuelle : immdiat par dfinition !

3 Solutions avec blocage

Schma moniteur
monitor <monitor-name> {
<shared variables + conditions declarations>
procedure P1 () {
...
}
procedure P2 () {
...
}
procedure Pn () {
...
}
{ initialization code }
}

21

3 Solutions avec blocage

Moniteurs (2)

Exemple de moniteur : gestion de compte bancaire

Type Compte : moniteur

variable solde : entier
proc
procdure Etat
dbut
imprimer solde;
solde;
fin

/* ressource acc
accs exclusif */
/* en exclusion mutuelle avec Virement */

proc
procdure Virement(montant
Virement(montant : entier) /* en exc. mut. avec Etat & Virement */
dbut
solde := solde + montant;
montant;
fin
dbut
solde := 0 ;
fin

/* Initialisation du moniteur */

3 Solutions avec blocage

Moniteurs (3)

Exemple (suite)
Activits concurrentes :

Activit
Activit P :

Un_compte.Virement(
Un_compte.Virement(nP);
nP);

Activit
Activit Q :

Un_compte.Virement(
Un_compte.Virement(nQ);
nQ);
Un_compte.
Un_compte. Etat();

Activit
Activit R :

Un_compte.Virement(
Un_compte.Virement(nR);
nR);

Un_compte.
Un_compte. Etat();

22

3 Solutions avec blocage

Synchronisation en Java : moniteur

Elments synchroniss :

Objets

Classes

Principes dun moniteur

Mthodes synchronises =
excutes en exclusion
mutuelle

Oprations wait et
notify/notifyAll

pour grer une
unique variable de condition
associe au moniteur

class ExMut {
int cpt; // shared data of the instance
public synchronized void dec() {
cpt--; // cest une section critique
}
public synchronized void inc() {
cpt++; // cest une autre SC
}
}
class SynchroCond {
int cpt; // shared data
public synchronized void get() {
if (cpt <= 0) wait();
cpt--; // cest bien sr une SC !
}
public synchronized void put() {
cpt++;
notify();
}
}

3 Solutions avec blocage

Principe mise en oeuvre moniteur en

Java (1/2)

Tout objet et toute classe possdent un verrou

transparent pour le programmeur (intrinsic lock)

Gestion FIFO / non FIFO dpend du JDK

Cest quoi un verrou ?

simplement un outil de synchro bloquant sur une condition
libre ou occup

Qui peut simplanter avec attente active ou passive
(auquel est associ une queue dattente si passive)
Mthodes synchronises :
Mthode dinstance :
currentObject.lock()
<mthode>
currentObject.unlock()

Mthode de classe (static):

currentClass.lock()
<mthode>
currentClass.unlock()

23

3 Solutions avec blocage

Principe mise en oeuvre moniteur en

Java (2/2)

Tout objet et toute classe possdent en plus
une file de processus bloqus

Parce quun moniteur Java fournit une (seule) var.
de condition (anonyme)
wait() :
put(current_thread, blocked)
current.unlock() // le moniteur devient libre
<stop the current thread>
current.lock() // la thread doit acqurir de
// nouveau le verrou en se rveillant,
//car, lexcution se poursuivra DANS le
// moniteur
}

notify() :
if !empty(blocked) {
thread = get(blocked)
wakeup(thread)
}

3 Solutions avec blocage

Simuler loutil smaphore avec

loutil moniteur (Java)

Bon exercice pour bien saisir les diffrences et les
subtilits dimplmentation: une version possible
class Semap {
int Val;
public synchronized void Init(int v) {
Val=v;
}
public synchronized void P() {
if ou while 1 (Val = 0) {
wait();
}
2 Val = Val 1;
}
public synchronized void V() {
 Val = Val + 1;
 notify(); // ou notifyAll();
}
}

Entrelacer des P ?

Test et modif. de Val:
dans une SC ? OUI

1 et si test False, 2

Entrelacer des P et V ?

Test de val et
manipulation de la
file: dans une SC ? OUI

1  

24

3 Solutions avec blocage

Classe Smaphore de Java 1.5+

class Semaphore { // import java.util.concurrent.Semaphore
public void acquire()
// Acquires a permit from this semaphore, blocking until one is available, or the
// thread is interrupted.
public void acquire(int permits)
// Acquires the given number of permits
public int availablePermits()
// Returns the current number of permits available in this semaphore.
public Collection<Thread> getQueuedThreads()
// Returns a collection containing threads that may be waiting to acquire.
public boolean isFair()
// Returns true if this semaphore has fairness set true.protected => FIFO order in the
queue
public void release()
// Releases a permit, returning it to the semaphore.
public boolean tryAcquire()
// Acquires a permit from this semaphore, only if one is available at the time of
invocation.

4 Conclusions

Bilan des mises en oeuvre doutils

de synchronisation

Pour implanter les outils de synchronisation avec
attente (forcment!), on a besoin dautres outils pour
grer de lexclusion mutuelle

atomicit dune squence dinstructions, aussi (de)bloquer un
processus

en pratique, ce sont des solutions de plus bas niveau
dabstraction. Exemples :

Masquer les interruptions durant lexcution de P

ou utiliser lalgo avec TAS, bas sur attente active pour
implanter la primitive P

Bloquer un processus, ranger son contexte, le rendre ligible
partir de son contexte, dans limplantation dun P ou V

Ou utiliser des smaphores ou des verrous (smaphore ultra
simplifi) pour implanter un moniteur

25

4 Conclusions

Ne pas systmatiquement bloquer ! (1/2)

With locking, if one thread attempts to acquire a lock that is
already held by another thread, the thread will block until the
lock becomes available. This approach has some obvious
drawbacks, including the fact that while a thread is blocked
waiting for a lock, it cannot do anything else. This scenario could
be a disaster if the blocked thread is a high-priority task (a
hazard known as priority inversion).

Concurrent algorithms based on TAS (+/- CAS) are called lockfree (also non-blocking), because threads do not ever have to
wait for a lock (sometimes called a mutex mutual exclusion
lock). Either the TAS operation succeeds or it doesn't, but in
either case, it completes in a predictable amount of time. If the
TAS fails, the caller can retry the TAS operation or take other
action as it sees fit.

Atomic variable de JDK 5+ : variable volatile, permet dtre accde
(consultation ou modification) en exclusion mutuelle, dune manire
efficace grce lutilisation dun TAS (la SC est trs courte)

Voir package java.util.concurrent.atomic

4 Conclusions

Ne pas systmatiquement bloquer ! (2/2)

Software Transactional Memory (STM)

Non-blocking execution. In STM schemes, code
just runs. There are no blocks, waits, waits for
locks, and so forth. At the end (the "commit")
it's all either going to work, or not. If it fails,
no changes made are visible. If it commits, all
changes are visible.

A suivre, cest un sujet trs actuel!
en.wikipedia.org/wiki/Software_transactional_memory

26