Sunteți pe pagina 1din 37

Sincronizarea executiei

proceselor

Proces independent

Execuia sa nu poate afecta sau nu poate fi afectat de ctre execuia altor procese
din sistem
Poate fi oprit i repornit fr a genera efecte nedorite
Este determinist (rezultatele depind numai de starea de intrare)
Este reproductibil (rezultatele sunt totdeauna aceleai, penury aceleai condiii de
intrare)
Nu se afl niciodat n aceeai stare ca i alte procese din sistem
Nu folosete n comun date (temporare sau permanente) cu alte procese

Proces cooperant

Execuia sa poate afecta sau poate fi afectat de ctre execuia altor procese din
sistem
Nu este determinist (rezultatele depind de secvena relativ de execuie, nu pot fi
prevzute cu anticipaie)
Nu este reproductibil (rezultatele nu sunt ntotdeauna aceleai pentru aceleai
condiii de intrare)
Se poate afla n aceeai stare ca i alte procese din sistem
De cele mai multe ori, folosete n comun date cu alte procese.

Problema producator-consumator
Apare destul de frecvent n cadrul sistemelor de
operare
Procesul de tip productor genereaz informaiile
care vor fi folosite de ctre procesul de tip
consumator
Exemplu:
modulul ce preia informaii de la un dispozitiv de
scanare a imaginii
modulul specializat n prelucrarea i afiarea
imaginii pe ecran

Pentru ca procesele s se poat executa n mod concurent,


trebuie creat o rezerv de date (ntr-o zon buffer, de
exemplu) care s poat fi umplut de ctre productor i golit
de ctre consumator, astfel nct productorul s poat pune
informaii ntr-un buffer, n timp ce consumatorul ia informaii
din alt buffer
Rezerva de buffer-e = structur de date folosit n comun de
ctre procesele productor i consumator
Numar nelimitat de buffer-e fara restrictii !!!
Numar limitat de buffer-e (DIM)productorul i
consumatorul trebuie s fie sincronizai:
consumatorul s atepte dac rezerva de date este goal
productorul s atepte dac zona este plin

Elemente folosite in comun:


#define DIM 10
typedef struct {. . .} element; /*tipul informatiei*/
element buffer[DIM];
/*zona buffer*/
int in = 0, out = 0;
/*pot lua valorile 0, 1, DIM-1*/

Semnificatii:
in arata urmatorul buffer gol
out arata primul buffer plin
Daca in==out, rezerva este goala.
Daca (in+1)%DIM==out, rezerva este plina
Consecinta: pot fi simultan pline doar DIM-1 buffer-e

Elemente locale unui proces:


nextp pentru memorare element in Producator
nextc pentru memorare element in Consumator

Producator:
while (true)
{ /* in nextp se produce o informatie*/
while ((in + 1) % DIM) == out) ; /*nimic ! nu exista buffer gol*/
buffer[in] = nextp;
in = (in + 1) % DIM;
}

Consumator:
while (true)
{ while (in == out) ; /*nimic ! nu exista buffer plin*/
nextc = buffer[out];
out = (out + 1) % DIM;
/* se consuma informatia din nextc*/
}

In varianta anterioara puteau fi pot fi simultan pline


doar DIM-1 buffer-e
Dorim sa poata fi simultan pline DIM buffer-e o
noua variabila comuna:
contor
Numarul curent de buffer-e pline
Initializat cu 0
Incrementat de procesul Producator
Decrementat de procesul Consumator

Producator:
while (true)
{ /* in nextp se produce o informatie*/
while ( contor == DIM ) ; /*nimic ! nu exista buffer gol*/
buffer[in] = nextp;
in = (in + 1) % DIM;
contor = contor+1;
}

Consumator:
while (true)
{ while (contor==0) ; /*nimic ! nu exista buffer plin*/
nextc = buffer[out];
out = (out + 1) % DIM;
contor = contor-1;
/* se consuma informatia din nextc*/
}

OBSERVATIE:
Rezultatul va depinde de secventa de executie relativa a celor 2 procese!
contor=contor+1;

reg1=contor;
reg1=reg1+1;
contor=reg1;

Executie concurenta a:
contor=contor+1;
contor=contor- 1;

executie secventiala a instructiunilor masina


care se intretes in mod arbitrar

Ex.: Presupunem contor=5. Se executa Producator si Consumator. Ulterior, valoarea


contor va deveni 4, 5 sau 6, desi corect ar fi sa devina 5!
De exemplu:
P
reg=contor
P
reg1=reg1 + 1
C
reg2=contor
C
reg2=reg2 1
P
contor=reg1
C
contor=reg2

5
6
5
4
6
4

Variabila contor este folosita si modificata de


ambele procese (este comuna!):
accesul trebuie controlat
o problema de sectiune critica

Problema seciunii critice - PSC


sistem format din n procese cooperante p0 ,
p1 ,..., pn-1

fiecare proces conine un segment de cod


numit seciune critic, n care:
citete variabile comune, reactualizeaz un tabel,
scrie un fiier etc.

trebuie ca execuia seciunilor critice s fie


mutual exclusiv n timp --- cnd unul dintre
procese i execut propria seciune critic nici
un alt proces s nu se afle ntr-o situaie
similar!!!

Rezolvarea PSC
Proiectarea unui protocol de cooperare:
fiecare proces trebuie s cear permisiunea de a
intra n propria seciune critic (seciunea de
intrare)
i s anune celelalte procese atunci cnd prsete
aceast seciune (seciunea de ieire)
while (conditie)
{ sectiunea de intrare;
sectiunea critica;
sectiunea de iesire;
sectiunea ramasa;
}

Soluia PSC este corect dac ndeplinete


3 cerine:
excludere mutual
progres:
la competiie particip numai acele procese ce
nu se afl n seciunea rmas
alegerea se realizeaz n timp finit

ateptare limitat - se acord un numr


limitat de permisiuni de intrare n propria
seciune critic pentru celelalte procese

Soluii software ale PSC pentru sisteme cu 2


procese
Presupunnd c
se lucreaz cu procesele p0 i p1,
n prezentarea algoritmului
(pentru asigurarea generalitii)
cele 2 procese vor fi notate cu pi , respectiv pj

ALGORITMUL 1.
Cele dou procese folosesc n comun o variabil de tip ntreg numit Rnd care poate fi iniializat cu
0 sau cu 1.
Atunci cnd Rnd=i, pi primete permisiunea de a executa propria seciune critic.
Structura procesului:
repeat
while (Rnd <> i) do Nimic;
seciunea critic;
Rnd =j ;
seciunea rmas;
until (condiie);

Soluia asigur excluderea mutual dar nu i cerina de progres, deoarece execuia seciunii
critice necesit n mod strict alternarea proceselor; de exemplu, dac Rnd=0 i p1 dorete s
intre n seciunea critic, nu o poate face, chiar dac p0 se afl n seciunea rmas.

ALGORITMUL 2.
Algoritmul anterior preciza procesul ce poate executa seciunea critic, fr s in cont de starea
proceselor.
nlocuim variabila Rnd cu tabloul var Flag : array 0..1 of boolean, ale crui elemente se iniializeaz cu
valoarea False.
Impunem ca atunci cnd procesul pi i execut propria seciune critic s fie ndeplinit condiia
Flagi=True

Structura procesului pi devine:


repeat
while
Flagj
Flagi:=True ;
seciunea critic
Flagi:=False ;
seciunea rmas
until condiie;

do

Nimic;

Soluia nu ndeplinete cerina de excludere mutual:


T0 : p0 execut while i gsete Flag1=False;
T1 : p1 execut while i gsete Flag0=False;
T2 : p1 execut Flag1:=True i intr n SC;
T3 : p0 execut Flag0:=True i intr n SC.

ALGORITMUL 3.
n algoritmul 2, procesul pi analizeaz starea lui pj i decide ce are de fcut nainte ca pj s poat
schimba starea variabilei Flagj.
Dac vectorul Flag va fi folosit cu semnificaia " Flagi=True indic doar c pi dorete s intre
n seciunea critic", structura procesului pi devine:
repeat
Flagi:=True;
while Flagj do Nimic;
seciunea critic
Flagi:=False ;
seciunea rmas
until condiie;

Cerina de excludere mutual este satisfcut, dar nu se realizeaz cea referitoare la progres.
De exemplu, dac apare urmtoarea secven de execuie:
T0 : p0 execut Flag1:=True;
T1 : p1 execut Flag0:=True,
att p0 ct i p1 rmn n bucl infinit (n cadrul instruciunilor while corespunztoare).

ALGORITMUL 4.
Combin avantajele algoritmilor 3 i 1.
Procesele folosesc n comun 2 variabile:
Flag: array 0..1 of boolean, iniializat cu False
Rnd:0..1, iniializat cu 0 sau 1
Structura procesului pi devine:
repeat
Flagi:=True;
Rnd:=j;
while (Flagj and (Rnd=j) do Nimic;
seciunea critic
Flagi:=False ;
seciunea rmas
until condiie;

Respect toate cele trei cerine de corectitudine ale PSC:

Excludere mutual
Atunci cnd pi dorete s-i execute seciunea critic, el nscrie Flagi cu
valoarea True i presupune c este dreptul celuilalt proces s intre n propria
seciune critic (Rnd:=j).
Dac ambele procese ncearc simultan s obin acces n seciunile critice,
Rnd primete aproape n acelai moment de timp att valoarea i ct i valoarea
j, dar numai ultima dintre atribuiri va genera valoarea final. Aceast valoare va
decide care proces va primi permisiunea de a intra n propria seciune critic.
Fiecare proces pi poate intra n seciunea critic numai atunci cnd
Flagj=False sau Rnd=i.
Dac fiecare dintre cele dou procese ar dori s-i execute simultan seciunile
critice, atunci Flag0=Flag1=True. Dar p0 i p1 nu-i pot ncheia instruciunile
while n aproape acelai moment de timp deoarece variabila Rnd poate lua fie
valoarea 0, fie valoarea 1, dar nu pe amndou odat. De aceea, numai unul
dintre procese, s presupunem pj , i ncheie cu succes instruciunea while.
Atta timp ct pj se afl n seciunea critic, se menin condiiile Flagj=True
i Rnd=j , ceea ce face ca procesul pi s nu poat trece de instruciunea while ,
excluderea mutual fiind deci asigurat.

Progres i ateptare limitat


Procesul pi poate fi mpiedicat s intre n seciunea critic numai dac este blocat n
bucla while cu condiia Flagj=True i Rnd=j.
Daca pj nu dorete s intre n seciunea critic, Flagj=False iar pi obine accesul.
Daca ns pj a setat Flagj=True i execut instruciunea while, atunci variabila Rnd
poate avea una dintre valorile i sau j:
dac Rnd=i, n seciunea critic va intra procesul pi
dac Rnd=j accesul va fi obinut de ctre pj.

Totui, n momentul n care pj prsete seciunea critic, el execut Flagj:=False,


permind accesul procesului pi n propria seciune critic.
Dac pj ar formula din nou cerere de intrare, ar trebui s execute att Flagj:=True
ct i Rnd:=i i deoarece pi nu schimb valoarea variabilei Rnd n timp ce i
execut instruciunea while, pi va intra n seciunea critic (progres) dup cel mult
un acces obinut de ctre pj (ateptare limitat).

Soluii software pentru sisteme cu N procese


ALGORITMUL 5.
Se consider c cele n procese folosesc n comun urmtoarele structuri de
date:
Flag: array 0..n-1 of (Inactiv, CereIn, nSC);
Rnd: 0..n-1;
Iniial, toate componentele vectorului Flag au valoarea Inactiv, iar Rnd are o
valoare oarecare, ntre 0 i n-1.
Semnificaia valorilor ce pot fi atribuite componentelor tabloului Flag este:

Inactiv dac procesul nu intr n competiie pentru ocuparea seciunii critice;


CereIn dac procesul dorete s intre n seciunea critic;
nSC dac procesul se afl n seciunea critic.

Structura procesului pi devine:


var j:0..n;
repeat
repeat
Flag i:=CereIn;
j:=Rnd;
while j<>i do if Flagj<>Inactiv then j:=Rnd
else j:=(j+1) mod n ;
Flag i:=nSC;
j:=0;
while (j<n) and (j=i) or (Flag j<>nSC)) do j:=j+1;
until (j>=n) and ((Rnd=i) or (Flag Rnd=Inactiv)) ;
Rnd:=i;
seciunea critic
j:=(Rnd+1) mod n;
while Flag j=Inactiv do j:=(j+1) mod n ;
Rnd:=j;
Flag i:=Inactiv ;
seciunea rmas
until condiie;

Demonstrarea corectitudinii:
Cerina de excludere mutual: se observ c fiecare pi primete permisiunea
de a intra n seciunea critic numai dac Flagj<>nSC pentru toi j<>i. Dar numai pi
poate seta Flagi=nSC iar pi inspecteaz Flag j numai atta timp ct Flagi=nSC.

Cerina de progres: valoarea variabilei Rnd poate fi modificat numai atunci


cnd un proces intr sau iese n / din seciunea critic; altfel, valoarea acestei
variabile rmne constant i n seciunea critic va intra primul proces din irul ciclic
de procese concurente (pRnd , pRnd+1 , ...pn-1 , p0 , , pRnd-1).
Cerina de ateptare limitat: fiecare proces care prsete seciunea critic
este obligat s desemneze ca unic succesor primul proces din irul ciclic curent, astfel
nct fiecare proces care formuleaz cerere de intrare n seciunea critic va primi
permisiunea de acces dup cel mult n-1 execuii n seciunea critic realizate de ctre
celelalte procese.

ALGORITMUL 6.
O alt soluie a problemei seciunii critice n cazul sistemelor cu n procese este
algoritmul de tip "brutrie" (bakery algorithm), destinat n principal mediilor
distribuite dar care poate fi prezentat i n contextul mediilor centralizate.
Ideea de baz: se asociaza fiecrui nou proces ("client al brutriei") un numr
("bon de ordine"), procesele urmnd s intre n seciunea critic ("s fie servite") n
ordinea cresctoare a acestor numere.
Deoarece algoritmul nu exclude posibilitatea ca dou sau mai multe procese s
primeasc numere identice, ntr-o astfel de situaie procesele sunt "servite" n ordinea
numelor: dac pi i pj primesc acelai numr i i<j, pi va fi primul servit. Deoarece
numele proceselor sunt unice i total ordonate, algoritmul este complet determinist.
Cele n procese folosesc n comun urmtoarele structuri de date:
Alegere: array 0..n-1 of boolean;
Numr: array 0..n-1 of integer,
ale cror componente sunt iniializate cu valorile False i respectiv 0.
n plus, pentru comoditatea exprimrii se folosesc urmtoarele notaii:
(a,b) < (c,d) dac a<c sau dac a=c i b<d;
max(a0,...,an-1) este un Numr k, astfel nct k >= ai pentru i=0,...n-1.

Structura procesului pi devine:


repeat
Alegerei:=True;
Numri:=max(Numr0,Numr1,...,Numrn-1)+1;
Alegerei:=False;
for j:=0 to n-1 do
begin
while Alegerej do Nimic;
while Numrj<>0 and (Numrj,j)<(Numri,i) do Nimic;
end;
seciunea critic
Numri:=0;
seciunea rmas
until condiie;

Demonstrarea corectitudinii:
Se arat mai nti c dac pi se afl n seciunea critic i pk(k<>i) a ales
deja Numrk<>0, atunci (Numri,i)<(Numrk,k).
Cerina de excludere mutual este ndeplinit deoarece dac, de
exemplu, pi se afl n seciunea critic, iar pk ncearc s intre n
seciunea critic, atunci cnd pk execut ce-a de-a doua instruciune
while, pentru j=i gsete Numr i<>0 i (Numri,i)<(Numrk,k) i
rmne n bucl pn n momentul n care pi prsete seciunea critic.
Celelalte dou cerine de corectitudine a soluiei problemei seciunii
critice, progresul i ateptarea limitat, sunt automat asigurate
deoarece se observ c procesele intr n seciunea critic pe baza regulii
primul-sosit-primul-servit .

Soluionarea hardware a PSC


PSC poate fi rezolvat simplu dac nu se permite apariia nteruperilor n timpul modificrii
unei variabile accesate n comun de ctre mai multe procese.

Instruciuni hardware speciale (atomice)- ntr-un ciclu instruciune se realizeaz:


testarea i modificarea coninutului unui cuvnt
interschimbarea coninutului a dou cuvinte
Definire abstract, fr a le particulariza pentru un anumit sistem de calcul:

function TestSiSet (var tinta: boolean): boolean;


begin TestSiSet:=tinta;
tinta:=True;
end;
procedure Interschimb (var a,b:boolean);
var temp: boolean;
begin temp:=a;
a:=b;
b:=temp
end;

Dac sistemul de calcul permite utilizarea instruciunii TestiSet, excluderea


mutual poate fi implementat prin declararea unei variabile de tip boolean, Zvor,
iniializat cu valoarea False.
repeat
while TestiSet(Zvor) do Nimic
seciunea critic
Zvor:=False;
seciunea rmas
until condiie;

Atunci cnd sistemul de calcul permite utilizarea instruciunilor de tip Interschimb,


excluderea mutual va putea fi asigurat ntr-un mod asemntor: se declar o variabil
global de tip boolean Zvor se iniializeaz aceast variabil cu valoarea False. n plus,
fiecare proces va avea o varilabil local de tip boolean numit Cheie.
repeat
Cheie:=True;
repeat
Interschimb(Zvor,Cheie);
until Cheie=False;
seciunea critic
Zvor:=False;
seciunea rmas
until condiie;

Deoarece variantele prezentate anaterior nu satisfac cerina de ateptare limitat


este necesar s se utilizeze variabile adiionale.

Algoritmul care folosete instruciuni TestiSet i satisface toate cerinele


problemei seciunii critice.
Structurile de date comune sunt :

var Ateptare: array 0..n-1 of boolean;


Zvor: boolean;
i au iniial valoarea False.

Structura procesului Pi va fi:


var j:0..n-1;
Cheie: boolean;
repeat
Ateptare i:=True;
Cheie:=True;
while Ateptarei and Cheie do Cheie:=TestiSet(Zvor);
Ateptarei:=False;
seciunea critic
j:=(j+1) mod n ;
while (j<>i) and (not Ateptarei) do j:=(j+1) mod n; if
then Zvor:=False
else Ateptarej:=False;
seciunea rmas
until condiie;

j=i

Demonstrarea corectitudinii:
Cerina de excludere mutual: se observ c procesul Pi poate intra n propria
seciune critic numai dac Ateptarei=False sau Cheie=False. Cheie poate lua
valoarea False numai n urma execuiei TestiSet. Primul proces care va executa
TestiSet va gsi valoarea Cheie = False iar toate celelalte vor fi nevoite s atepte.
Ateptarei poate lua valoarea False numai dac un alt proces prsete propria
seciune critic; un singur element Ateptarei primete valoarea True, asigurnd
astfel ndeplinirea cerinelor de excludere mutual.
Cerina de progres: se pot folosi aceleai argumente - un proces care prsete
propria seciune critic va seta fie Zvor la valoarea False, fie Ateptarej = False,
ceea ce va permite altui proces s intre n propria seciune critic.
Cerina de ateptare limitat: se observ c atunci cnd un proces prsete
propria seciune critic, el parcurge vectorul Ateptare n ordinea ciclic (i+1,i+2, ...
n-1, 0, ... i-1) i desemneaz ca urmtor proces care s intre n propria seciune
critic primul proces din vectorul parcurs n acest mod care se afl n seciunea de
intrare (Ateptarej=true). Prin urmare, fiecare proces care dorete s intre n
propria seciune critic ateapt pe durata a cel mult (n-1) astfel de cicluri.

Semafor
= instrument de sincronizare
Definiie:
o variabil de tip ntreg care, n afar de iniializare, poate fi
accesat numai prin intermediul a dou operaii standard de tip
atomic: Wait (ateapt) i Signal (semnalizeaz)
Wait(S):

Signal(S):

while S<=0 do Nimic;


S:=S-1;
S:=S+1

Utilizare: n elaborarea unor soluii corecte ale problemei


seciunii critice (cazul unui sistem cu N procese), n rezolvarea
unor probleme de sincronizare etc.

Counting semaphore (semafor contor)


Poate avea o valoare intreaga oarecare
Exemplu :
valoarea semaforului se initializeaza cu numarul de resurse
disponibile la care doresc acces mai multe procese
un proces doreste o resursa: wait(semafor) - decrementare
un proces elibereaza o resursa: signal(semafor) incrementare
Valoarea 0 (zero) a semaforului toate resursele sunt ocupate

Binary semaphore (semafor binar)


Poate avea doar valorile 0 sau 1
Este mai simplu de implementat
Se mai numeste mutex lock (se foloseste frecvent pt.
asigurarea excluderii mutuale)

Dac se consider c N procese folosesc n comun un acelai semafor, notat AccSC i


iniializat cu valoarea 1, o soluie corect a problemei seciunii critice este scrierea fiecrui
proces Pi sub forma:
repeat
Wait (AccSC);
seciunea critic
Signal (AccSC);
seciune rmas
until condiie;

Considerand 2 procese cu execuie concurent, p1 i p2 care conin instruciunile S1 i


respectiv S2, dac se dorete ca S2 s se execute numai dup ce s-a ncheiat execuia S1,
cele dou procese pot utiliza n comun un semafor notat Sincr, iniializat cu valoarea 0,
astfel:
(n procesul p1 )
...
S1;
Signal (sincr);
...

(n procesul p2 )
...
Wait(Sincr)
S2;
...

Principalul dezavantaj al soluiilor software ce asigur excluderea mutual i al


definiiei semaforului prezentat anterior este "ateptarea n ocupat"
(busy-waiting):
Atunci cnd un proces se afl n seciunea critic, orice alt proces care
ncearc s intre n seciunea critic este blocat n execuia buclei din
seciunea de intrare, irosind cicluri ale UC pe care alte procese ar putea
s le foloseasc n mod productiv.
semafor SPINLOCK (procesul cicleaza spins asteptand semaforul)

Avantaj: nu mai este necesara comutare de context (costisitoare) pt.


procesul ce asteapta

Consecinta: poate fi folosit pentru procese


cu durata scurta de asteptare (de ciclare)
in sisteme multiprocesor
un thread spins pe un procesor (cu un semafor)
alt thread se executa pe alt procesor

Eliminare busy-waiting: alt mod de implementare a semafoarelor (definiii


modificate ale operaiilor Wait i Signal)
Atunci cnd un proces execut operaia Wait i constat c valoarea semaforului nu este
pozitiv, n loc s efectueze o ateptare n "ocupat" intr n starea blocat, adic trece n
starea de ateptare pe semafor, controlul fiind transferat planificatorului UC (vom
vedea!) care selecteaz alt proces n vederea execuiei.
Procesul blocat (care ateapt pe un anumit semafor) redevine apt pentru continuarea
execuiei abia n momentul n care un alt proces execut operaia Signal pe semaforul
respectiv; prin intermediul unei operaii de "trezire" (wakeup), se schimb starea
procesului de la blocat la gata de execuie (ready).
In functie de algoritmul de planificare, UC va fi sau nu alocata apoi procesului trezit.
Planificator UC
ready

running
Wait(s)

Signal(s)
(Wakeup System Call)

waiting

(Block
System Call)

type semafor = record


valoare: integer;
L : list of proces;
end;

Fiecare semafor conine o valoare ntreag i o list de procese.


Atunci cnd un proces trebuie s atepte pe un semafor, este adugat la lista
proceselor;
Activarea unui proces se realizeaz cu ajutorul unei operaii Signal care scoate
procesul din lista de ateptare i apoi l trece n starea "gata de execuie" (ready).
Wait(S): S.valoare:=S.valoare-1;
if S.valoare < 0 then
begin
adaug procesul la S.L;
blocheaz;
end;

|S.valoare| == nr. procese ce asteapta pe semafor


(pt. S.valoare <0)

Signal(S): S.valoare:=S.valoare+1;
if S.valoare<=0 then
begin
extrage din S.L procesul P ;
wakeup(P) ;
end;

Lista proceselor poate fi implementat n fiecare bloc de control al procesului


(BCP), cu ajutorul unui cmp de legtur: fiecare semafor va conine o valoare
ntreag i un indicator ctre lista de blocuri de control ale proceselor.
Algoritmul de organizare a introducerii/extragerii proceselor din list nu
influeneaz mecanismul de funcionare a semaforului.
O problem deosebit: asigurarea execuiei de tip atomic a operaiilor Wait i Signal.
O astfel de situaie reprezint o problema de seciune critic i poate fi soluionat n
urmtoarele dou moduri:

n mediu uniprocesor (o singur UC) se poate utiliza dezactivarea ntreruperilor


pe durata execuiei operaiilor Wait i Signal; metoda este eficient deoarece
dezactivarea ntreruperilor face imposibil intercalarea instruciunilor aparinnd
diferitelor procese;

n mediu multiprocesor, dezactivarea ntreruperilor nu mai este eficient deoarece


instruciunile aparinnd diferitelor procese (care se execut pe procesoare diferite)
pot interfera arbitrar. Pentru rezolvarea problemei, daca nu se recurge la utilizarea
unor instruciuni speciale, se poate folosi oricare dintre soluionrile software
corecte ale problemei seciunii critice (algoritmii 4, 5, 6) n care se va considera c
seciunile critice sunt formate din procedurile Wait i Signal.

Prin utilizarea definiiilor modificate ale operaiilor Wait i Signal "ateptarea n


ocupat" nu a fost complet eliminat, ci a fost restrns la seciunile critice ale
operaiilor Wait i Signal, care dureaz destul de puin (n cazul n care sunt
codificate corect, conin cel mult 10 instruciuni) i sunt ocupate destul de rar.
Dac nu s-ar fi ales aceast soluie, "ateptarea n ocupat" s-ar fi produs la
nivelul seciunilor critice ale programelor de aplicaie, care uneori sunt foarte
lungi (pot dura chiar ore ntregi) sau sunt aproape tot timpul ocupate, ceea ce ar
fi condus la o exploatare ineficient a sistemului de calcul.