Chương 5: Đồng bộ hóa tiến trình pptx

Phm Th Phi ©2004
5.1
H điu hành
Chng 5: ng b hóa tin trình
̈ C s
̈ Bài toán min tng trc
̈ ng b hóa bng phn cng
̈ Semaphores
̈ Các bài toán c đin v đng b hóa
̈ Monitors
̈ ng b hóa trong Solaris và Windows 2000
Phm Th Phi ©2004
5.2
H điu hành
C s
̈ Truy cp cnh tranh lên d liu đc chia s có th gây nên tình
trng không nht quán d liu.
̈ Vic duy trì s nht quán d liu yêu cu các c ch đ đm bo
s thc thi mt cách có th t ca các tin trình có hp tác vi
nhau.
̈ Ví d?
Phm Th Phi ©2004
5.3
H điu hành
Tình trng đua tranh
̈ Tình trng đua tranh:làtình trng mà vài tin trình cùng truy cp và
thay đi lên d liu đc chia s.Giátr cui cùng ca d liu chia s
ph thuc vào tin trình nào hoàn thành cui cùng.
̈  ngn chn tình trng đua tranh, các tin trình đua tranh phi đc
đng b hóa.
Phm Th Phi ©2004

5.4
H điu hành
Vn đ min tng trc
̈ Tt c n tin trình đang cnh tranh đ s dng d liu chia s.
̈ Mi tin trình có mt đon mã lnh, gi là min tng trc, mà
trong đócóhành đng truy cp d liu đc chia s.
̈ Vn đ – đm bo rng khi mt tin trình đang chy trong
min tng trc, không có mt tin trình nào khác đc cho
phép chy trong min tng trc ca mình.
Phm Th Phi ©2004
5.5
H điu hành
Gii pháp cho vn đ min tng trc
1. Loi tr h tng.Nu tin trình P
i
đang thc thi trong min
tng trc, thì không có tin trình nào khác có th thc thi
trong min tng trc ca mình.
2. Tin trin.Nu không có tin trình nào đang thc thi trong
min tng trc ca nó và có tn ti vài tin trình đang mong
mun đc thc thi trong min tng trc ca chúng, thì vic
la chn cho mt tin trình bc vào min tng trc ca nó
không th b trì hoãn mãi đc.
3. Ch đi hu hn. Không có tin trình nào phi ch đi vnh
vin đ có th bc vào min tng trc ca nó
Phm Th Phi ©2004
5.6
H điu hành
Nhng c gng đu tiên đ gii quyt bài
toán min tng trc

̈ Ch có 2 tin trình, P
0
và P
1
̈ Cu trúc tng quát ca tin trình P
i
(tin trình kia là P
1-j
)
do {
entry section
critical section
exit section
reminder section
} while (1);
̈ Các tin trình có th chia s mt s bin chung đ đng b hóa hành
đng ca chúng.
Phm Th Phi ©2004
5.7
H điu hành
Gii thut1
̈ Các bin chung:
H int turn;
khi đu turn = 0
H turn = i ⇒ P
i
có th bc vào min tng trc ca nó
̈ Tin trình P
i
do {

while (turn != i) ;
critical section
turn = j;
reminder section
} while (1);
̈ Gii pháp này thõa mãn yêu cu v loi tr h tng nhng không
tin trin đc.
Phm Th Phi ©2004
5.8
H điu hành
Gii thut2
̈ Các bin chia s
H boolean flag[2];
khi đu flag [0] = flag [1] = false.
H flag [i] = true ⇒ P
i
sn sàng bc vào min tng trc ca nó
̈ Tin trình P
i
do {
flag[i] := true;
while (flag[j]) ;
critical section
flag [i] = false;
remainder section
} while (1);
̈ Thõa mãn yêu cu loi tr h tng, nhng không tin trin
Phm Th Phi ©2004
5.9
H điu hành

Gii thut3
̈ Kt hp các bin chia s đc s dng trong các gii thut 1
và 2.
̈ Tin trình P
i
do {
flag [i]:= true;
turn = j;
while (flag [j] and turn = j) ;
critical section
flag [i] = false;
remainder section
} while (1);
̈ Thõa mãn c 3 điu kin
Phm Th Phi ©2004
5.10
H điu hành
Gii thut Bakery
̈ Trc khi bc vào min tng trc ca mình, tin trình nhn
đc mt con s. Tin trình nào nhn đc con s nh nht
s có quyn bc vào min tng trc.
̈ If tin trình P
i
và P
j
nhn đc cùng mt s, và nu i<j,thìP
i
đc phc v trc; ngc li P
j
đc phc v trc.

̈ B sinh luôn luôn sinh ra các con s theo th t tng; ví d
1,2,3,3,3,3,4,5
Min tng trc cho n tin trình
Phm Th Phi ©2004
5.11
H điu hành
Gii thut Bakery
̈ Chú thích < dùng đ so sánh các cp (ticket #, process id #)
H (a,b) < c,d) if a < c or if a = c and b < d
H max (a
0
,…, a
n-1
)làs k, sao cho k ≥ a
i
for i =0,
…, n –1
̈ D liu chia s
boolean choosing[n];
int number[n];
Các d liu trên đc khi to tng ng là false và 0
Phm Th Phi ©2004
5.12
H điu hành
Gii thut Bakery
do {
choosing[i] = true;
number[i] = max(number[0], number[1], …, number [n – 1])+1;
choosing[i] = false;
for (j = 0; j < n; j++) {

while (choosing[j]) ;
while ((number[j] != 0) && ((number[j],j) < (number[i],i)) ;
}
critical section
number[i] = 0;
remainder section
} while (1);
Phm Th Phi ©2004
5.13
H điu hành
ng b hóa vi s tr giúp ca phn cng
̈ c và sa đi ni dung ca mt word mt cách t đng
boolean TestAndSet(boolean &target) {
boolean rv = target;
target = true;
return rv;
}
Phm Th Phi ©2004
5.14
H điu hành
Loi tr tng h vi Test-and-Set
̈ D liu đc chia s:
boolean lock = false;
̈ Tin trình P
i
do {
while (TestAndSet(lock)) ;
critical section
lock = false;
remainder section

}
Phm Th Phi ©2004
5.15
H điu hành
Loi tr tng h vi s tr giúp ca phn cng
̈ T đng swap hai bin
void Swap(boolean &a, boolean &b) {
boolean temp = a;
a = b;
b = temp;
}
Phm Th Phi ©2004
5.16
H điu hành
Loi tr tng h viSwap
̈ D liu chia s (khi to là false):
boolean lock;
boolean waiting[n];
̈ Tin trình P
i
do {
key = true;
while (key == true)
Swap(lock,key);
critical section
lock = false;
remainder section
}
Phm Th Phi ©2004
5.17

H điu hành
Semaphores
̈ Công c dùng đ đng b hóa không gây ra tình trng ch đi bn.
̈ Semaphore S –bin integer
̈ Ch có th đc truy cp thông qua hai thao tác nguyên t (không th
chia nh đc na):
wait (S):
while S≤
0 do no-op;
S ;
signal (S):
S++;
Phm Th Phi ©2004
5.18
H điu hành
Min tng trc ca n tin trình
̈ D liu chia s:
semaphore mutex; //khi đu mutex = 1
̈ Tin trình Pi:
do {
wait(mutex);
critical section
signal(mutex);
remainder section
} while (1);
Phm Th Phi ©2004
5.19
H điu hành
Cài đt Semaphore
̈ nh ngha mt semaphore nh là mt record

typedef struct {
int value;
struct process *L;
} semaphore;
̈ Gi s ta đã có hai thao tác:
H block – ngng tm thi tin trình gi thao tác này.
H wakeup(P) khi đng li tin trình đã b blocked P.
Phm Th Phi ©2004
5.20
H điu hành
Cài đt
̈ Các thao tác trên Semaphore bây gi đc đnh ngha nh sau:
wait(S):
S.value ;
if (S.value < 0) {
add this process to S.L;
block;
}
signal(S):
S.value++;
if (S.value <= 0) {
remove a process P from S.L;
wakeup(P);
}
Phm Th Phi ©2004
5.21
H điu hành
Semaphore nh là công c đng b hóa tng quát
̈ Thc thi B trong P
j

ch sau khi A đã đc thc thi trong P
i
̈ S dng semaphore flag khi to vi giá tr 0
̈ Code:
P
i
P
j
MM
Await(flag)
signal(flag) B
Phm Th Phi ©2004
5.22
H điu hành
Deadlock và cht đói
̈ Deadlock – hai hoc nhiu tin trình đang ch đi vô hn mt s
kin nào đó, mà s kin đóch có th đc to ra bi mt trong các
tin trình đang ch đi kia.
̈ Xem S và Q là 2 semaphores đc khi to là 1
P
0
P
1
wait(S); wait(Q);
wait(Q); wait(S);
MM
signal(S); signal(Q);
signal(Q) signal(S);
̈ S cht đói – b nghn (block) không hn đnh. Mt tin trình có th
không bao gi đc xóa khi hàng đi trong semaphore.

Phm Th Phi ©2004
5.23
H điu hành
Có hai kiu semaphore
̈ Semaphore tng dn– giá tr integer có th tri qua nhiu min
giá tr.
̈ Semaphore nh phân – giá tr integer ch nhn mt trong hai giá tr
0và1;cóth cài đt đn gin hn.
̈ Có th coi semephore nh phân là trng hp đc bit ca
semaphore tng dn.
Phm Th Phi ©2004
5.24
H điu hành
Các bài toán đng b hóa c đin
̈ Bài toán ngi sn xut-ngi tiêu dùng (Bounded-Buffer hay
Producer-Customer)
̈ Bài toán Readers and Writers
̈ Bài toán “5 nhà trit gia n ti” (Dining-Philosophers)
Phm Th Phi ©2004
5.25
H điu hành
Bounded-Buffer
̈ D liu chia s
semaphore full, empty, mutex;
Khi to:
full = 0, empty = n, mutex = 1
Phm Th Phi ©2004
5.26
H điu hành
Bounded-Buffer – tin trình Producer

do {
…
produce an item in nextp
…
wait(empty);
wait(mutex);
…
add nextp to buffer
…
signal(mutex);
signal(full);
} while (1);
Phm Th Phi ©2004
5.27
H điu hành
Bounded-Buffer – Tin trình Consumer
do {
wait(full)
wait(mutex);
…
remove an item from buffer to nextc
…
signal(mutex);
signal(empty);
…
consume the item in nextc
…
} while (1);
Phm Th Phi ©2004
5.28

H điu hành
Bài toán Readers-Writers
̈ D liu chia s
semaphore mutex, wrt;
Khi to
mutex = 1, wrt = 1, readcount = 0
Phm Th Phi ©2004
5.29
H điu hành
Readers-Writers – Tin trình Writer
wait(wrt);
…
writing is performed
…
signal(wrt);
Phm Th Phi ©2004
5.30
H điu hành
Readers-Writers – Tin trình Reader
wait(mutex);
readcount++;
if (readcount == 1)
wait(wrt);
signal(mutex);
…
reading is performed
…
wait(mutex);
readcount ;
if (readcount == 0)

signal(wrt);
signal(mutex):
Phm Th Phi ©2004
5.31
H điu hành
Bài toán nm nhà trit gia n ti
̈ D liu chia s
semaphore chopstick[5];
Khi đu, các giá tr là 1
Phm Th Phi ©2004
5.32
H điu hành
Bài toán nm nhà trit gia n ti
̈ Philosopher i:
do {
wait(chopstick[i])
wait(chopstick[(i+1) % 5])
…
eat
…
signal(chopstick[i]);
signal(chopstick[(i+1) % 5]);
…
think
…
} while (1);
Phm Th Phi ©2004
5.33
H điu hành
Monitors

̈ Cu trúc dùng đ đng b hóa đc cài đt  ngôn ng cp cao, nó cho phép
chia s an toàn mt kiu d liu tru tng nào đógia nhiu tin trình cnh
tranh.
monitor monitor-name
{
shared variable declarations
procedure body P1 (…) {
. . .
}
procedure body P2 (…) {
. . .
}
procedure body Pn (…) {
. . .
}
{
initialization code
}
}
Phm Th Phi ©2004
5.34
H điu hành
Monitors
̈  cho phép mt tin trình ch đi trong monitor, mt bin điu
kin phi đc khai báo nh sau:
condition x, y;
̈ Bin điu kin ch có th đc s dng vi hai thao tác wait và
signal.
H Thao tác
x.wait();

có ngha là tin trình đang gi thao tác này đang ng cho đn khi mt
tin trình khác gi
x.signal();
H Thao tác x.signal khi đng li chính xác mt tin trình đang ng đ
ch đi trên bin x. Nu không có tin trình nào đang ng trên x, thì
thao tác signal không gây nh hng gì c.
Phm Th Phi ©2004
5.35
H điu hành
Cái nhìn mt cách có s đ v Monitor
Phm Th Phi ©2004
5.36
H điu hành
Monitor vi các bin điu kin
Phm Th Phi ©2004
5.37
H điu hành
Ví d v cài đt bài toán 5 nhà trit gia n
ti trên monitor
monitor dp
{
enum {thinking, hungry, eating} state[5];
condition self[5];
void pickup(int i) // các slide k tip
void putdown(int i) // các slide k tip
void test(int i) // các slide k tip
void init() {
for (int i = 0; i < 5; i++)
state[i] = thinking;
}

}
Phm Th Phi ©2004
5.38
H điu hành
Các nhà trit gia n ti
void pickup(int i) {
state[i] = hungry;
test[i];
if (state[i] != eating)
self[i].wait();
}
void putdown(int i) {
state[i] = thinking;
// test left and right neighbors
test((i+4) % 5);
test((i+1) % 5);
}
Phm Th Phi ©2004
5.39
H điu hành
5 nhà trit gia n ti
void test(int i) {
if ( (state[(i + 4) % 5] != eating) &&
(state[i] == hungry) &&
(state[(i + 1) % 5] != eating)) {
state[i] = eating;
self[i].signal();
}
}