III. CÁ
C
Nguồn:
III.1.
Vấn
đ
tiến trìn
h
trình ki
a
Để đồn
g
sau :
Tiến tr
ì
đầy.(sy
n
Tiến tr
ì
trống.(s
y
Hai tiế
n
mutuell
e
Giải
p
I
II.1.
1
Sử dụn

ụ
y
nchronisa
t
n
t
r
ình sản
e
)
p
háp:
1
. Semaph
o
g
ba semap
h
n
g trong bộ
ờ
i đến bộ đ
ệ
Cổ ĐIểN
C
g
ười sản x
u
tr
ình cùng

đ
đệm; và m
u
ệ
m.
C
ủA ĐồN
G
u
ất – Ngư
ờ
c
hia sẻ mộ
t
ả
n xuất – t
ạ
ê
u thụ – lấ
y
ì
nh 3.17 P
r
a
hai tiến t
r
ì
r
) không đ
ư

ư
ợc ghi dữ l
ư
ợc đọc dữ
l
g
được thao
đã có dữ l
i
t
ra việc Pr
o
(
Producer
-
ó
kích thướ
c
u
và đặt dữ
bộ đệm ra
đ
C
onsume
r

ấ
t tiêu thụ c
ầ
iệu vào bộ

đệm cùng
ộ
đệm; emp
C
onsumer k
h
r
)
M
ột trong
h
ộ
đệm- và t
i
các quy đị
n
lúc . (excl
u
ty, đếm số
c
h
ông truy
x
h
ai
i
ến
n
h
u

e
n
u
p
u
p
}
}

Consu
m
{
int w
hi
l
d
o
d
o
r
e
u
p
u
p
c
o

item;
l
e (TRU
E
r
oduce
_i
o
wn(&em
p
o
wn(&mu
t
n
ter
_
it
e
p
(&mute
x
p
(&full)
m
er()
item;
l
e (TRU
E
o

n
n
t coun
t
c
edure
e
3;
t
ex = 1;
p
ty = Bu
f
l
l = 0;
E
) {
i
tem(&it
e
p
ty);
t
ex);
e
m(item)
;
x
);
;

nter();

/
/ s

f
ferSiz
ee
m); ;

/
/ g
m
);
/
/ r
/
/ t
m
);
u

/ tă
n

i
ả
m số
c
/
/ bá
o
// l
ấy
a kh
ỏ
i
m
ăng s
ố

c
// x
ử

mer với ha
i
h
ụ thuộc v
à
r
ong bộ

g s
ố
c
h
c
hỗ đầy
o
hi
ệu
y
dữ li
ệ
m
iền gă
n
c
hỗ trố
n
lý dữ
l
i
thủ tục e
n
à
o các biến
đ
đệm
r
uy xuấ
t

ter và rem
o
đ
iều kiện
fu
t
độc

ề
n găng
ộ
đệm
ề
n găng
đệm
o
ve thao tá
c
fu
ll và emp
tyc

ty
.
{
i
f


wh
{ }
}
Con
s
{

wh
{ }
}
I
II.1.
3
Thông
đ
công vi
ệ
một dữ
l
Consu
m
f
(coun

t
sign
a
n
t = 0;
monito
r
d
ucer();
h
ile (T
R
produce
Produce
s
umer();
h
ile (T
R
Produce
consume
3
. Trao đổi
đ
iệp empty
h
ệ
c bằng các
h
l

)
a
l(full)
;
r
;

R
UE)
_
item(&
i
rConsum
e

R
UE)
rConsum
e
_
item(i
t
thông điệ
p
h
àm ý có
m
h
gởi 4 thô
n

v
t
em);
p

m
ột chỗ trố
n
n
g điệp em
p
h
i nhận đư
ợ
ứ
a dữ liệu .
T
// n
ế
// đ
ặt
/
/ tă
n
// n
ếu
/
/ th
ì
// n

t
dữ li
ệ
n
g s
ố
c
h
u
bộ đệ
m
ì
kích
h
u
bộ đệ
m
y
dữ li
ệ
ả
m số c
h
u
bộ đệ
m
ì
kích
h
đệm. Tiến

h
ỗ đầy
m
không
đ
h
o
ạ
t Pro
d
tr
ình Cons
u
ế
n t
r
ình Pr
o
p
ty thì gởi n
c
hờ nhận t
h
phải c
h
ộ
đệm
t
rống
s

ứa
dữ liệu, và sau khi xử lý xong dữ liệu này, Consumer sẽ lại gởi một thông điệp empty đến
Producer,
BufferSize = 4;

Producteur()
{
int item;
message m; // thông điệp

while (TRUE) {
produce_item(&item);
receive(consumer,&m); // chờ thông điệp empty
create_message(&m, item); // tạo thông điệp dữ
liệu
send(consumer,&m); // gởi dữ liệu đến Consumer
}
}

Consumer()
{
int item;
message m;

for(0 to N)
send(producer, &m); // gởi N thông điệp
empty
while (TRUE) {
receive(producer, &m); // chờ thông điệp dữ
liệu

semap
h
semap
h
int r
c
Reade
r
{

w
hi
l

d

r

iu

r

d

r

i

t thời điể
m
u
tuelle exc
l
p
háp:
1
. Semaph
o
g
một biến
c
ệ
u. Hai se
m
m
tra sự tru
y
h
ore mu
t
h
ore db
c
;
r
()
l
e (TRU

p(&mut
e
u
se
_
dat
a
r
()
l
e (TRU
E
c
reate
_d
d
own(&d
b
w
rite
_
d
a
u
p(&db);
m
ột tiến trì
n
đ
ang truy x

db);
e
x);
t
abase()
;
u
tex);
- 1;
=
= 0)
&
db);
e
x); //
a_
read()
;
E
) {
d
ata();
b
);
a
tabase(
)

n
h Writer c

//
//
c
//
c
;

/
/
đ
//
g
//
b
//
n
//
c
ch
ấ
m d
ứ
; //
)
; //
//
ậ

g

g
iành q
u
t
hêm m
ột
nếu l
à

c
ấ
m Wri
t
c
h
ấ
m dứ
t
đ
ọ
c dữ l
i
g
iành q
u
b
ớ
t một

tiến t
r
ình
R
e
x, kiểm s
o
u
.
a
truy x
u
truy x
u
g
tiến t
r

u
y
ề
n tru
y
t
tiến t
r
Reader
đ
t
er truy

t truy
x
c
ơ sở dữ liệ
u
h
ronisatio
n
ử
a đổi nội
d
R
eader mu
ố
o
át sự truy
c
u
ất rc
u
ất cơ s
r
ì
nh Re
a
y
xuất
r
r
ì

)
d
ung cơ sở
d
ố
n truy xuấ
t
c
ập đến rc;
ở dữ li
ệ
a
der
r
c
a
der
n
thì
ữ
liệu
r
c
d
er
g
thì
x
uất db
db

{
i
f

r
c
s
i
}
pro
c
{

r

i }
pro
c
{
i
f

b
u
}
pro
c

r Read
e
o
nditio
n
n
t
o
olean
c
edure
B
f
(busy)
wait(
O
c
++;
i
gnal(O
K
c
edure
F
r
c ;
i
f (rc
=
sign

hile (
T
{

Read
e
c
hung rc đ
ể
n
t
r
ình Wri
t
n
h Reader
c
e
rWriter
n
OKWrit
e
rc =
busy =
B
eginRea
d

O
KRead);

(
OKRead)
;
(
OKWrite
)
T
RUE)
e
rWriter
.
ể
ghi nhớ s
ố
t
er phải ch
u
c
uối cùng s
ẽ
e
, OKRe
a
0;
false;
d
()

yển sang t
r
ẽ
đánh thức
a
d; /
/
t
ớ
t một
R
// n
ế

/
/ th
ì
ruy xu
ất
// n
ếu

/
/ Re
a
e
ad();

db đa
n
a
der đa
n
R
eader mu
ố
h
ờ nếu rc >
W
riter đan
g
db đang
t
Reader
e
ader cu
ố
h
ép Writ
e
n
g bận,
h
n
g đ
ọ
c d
b

e
{

w

{ }
}
I
II.2.
3
Cần có
m
Các tiế
n
từ serve
r
Reade
r
{

wh


R

W
Read
e
}

3
. Trao đổi
m
ột tiến t
r
ì
n
n
t
r
ình Writ
e
r
các thông
r
()
h
ile (T
R
se
n
re

d
a
R
eaderWr
i
W
rite
_
da
t
e
rWriter
.
thông điệ
p
n
h server đ
i
e
r và Read
e
điệp hồi đ
á
R
UE) {
n
d (serv
e
c
eive (s

i
ter.Be
g
t
abase()
.
Finish
W
p

i
ều khiển v
i
e
r gởi các t
h
á
p
t
ương ứ
n
e
r, Req
u
e
rver,
v
e
); }
a

v
alue);
e
);
u
estWri
t
K
Write);

();

ấ
t cơ sở dữ
y
êu cầu tru
y
d
);
t
e,value
)
}
liệu.
y
xuất đến
s
)
;
s

Sự chiếm giữ và yêu cầu thêm tài nguyên (Wait for): Các tiến trình tiếp tục chiếm giữ
các tài nguyên đã cấp phát cho nó trong khi chờ được cấp phát thêm một số tài nguyên
mới.
Không thu hồi tài nguyên từ tiến trình đang giữ chúng (No preemption)
: Tài nguyên
không thể được thu hồi từ tiến trình đang chiếm giữ chúng trước khi tiến trình này sủ
dụng chúng xong.
Tồn tại một chu kỳ trong đồ thị cấp phát tài nguyên ( Circular wait)
: có ít nhất hai tiến
trình chờ đợi lẫn nhau : tiến trình này chờ được cấp phát tài nguyên đang bị tiến trình kia
chiếm giữ và ngược lại.
Khi có đủ 4 điều kiện này, thì tắc nghẽn xảy ra. Nếu thiếu một trong 4 điều kiện trên thì
không có tắc nghẽn.
IV.3. Đồ thị cấp phát tài nguyên
Có thể sử dụng một đồ thị để mô hình hóa việc cấp phát tài nguyên. Đồ thị này có 2 loại
nút : các tiế
n trình được biễu diễn bằng hình tròn, và mỗi tài nguyên được hiển thị bằng
hình vuông

Hình 3.19 Đồ thị cấp phát tài nguyên
IV.4. Các phương pháp xử lý tắc nghẽn
Chủ yếu có ba hương tiếp cận để xử lý tắc nghẽn :
Sử dụng một nghi thức (protocol) để bảo đảm rằng hệ thống không bao giờ xảy ra tắc
nghẽn.
Cho phép xảy ra tắc nghẽn và tìm cách sữa chữa tắc nghẽn.
Hoàn toàn bỏ qua việc xử lý tắc nghẽn, xem như hệ thống không bao giờ xảy ra tắc
nghẽn.
IV.5. Ngăn chặn tắc nghẽn
Để tắc nghẽn không xảy ra, cần bảo đảm tối thiểu một trong 4 đ
iều kiện cần không xảy

, ,Rm} là tập các loại tài nguyên.
Các loại tài nguyên được phân cấp từ 1-N.
Ví dụ : F(đĩa) = 2, F(máy in) = 12
Các tiến trình khi yêu cầu tài nguyên phải tuân thủ quy định : khi tiến trình đang chiếm
giữ tài nguyên Ri thì chỉ có thể yêu cầu các tài nguyên Rj nếu F(Rj) > F(Ri).
IV.6. Tránh tắc nghẽn
Ngăn cản tắc nghẽn là một mối bận tâm lớn khi sử dụng tài nguyên. Tránh tắc nghẽn là
loại bỏ tất cả các cơ hội có thể dẫn đến tắc nghẽn trong tương lai. Cần phải sử dụng
những cơ chế ph
ức tạp để thực hiện ý định này.
Một số khái niệm cơ sở
Trạng thái an toàn : trạng thái A là an toàn nếu hệ thống có thể thỏa mãn các nhu cầu
tài nguyên (cho đến tối đa) của mỗi tiến trình theo một thứ tự nào đó mà vẫn ngăn chặn
được tắc nghẽn.
Một chuỗi cấp phát an toàn: một thứ tự của các tiến trình <P
1
, P
2
, ,Pn> là an toàn đối
với tình trạng cấp phát hiện hành nếu với mỗi tiến trình Pi nhu cầu tài nguyên của Pi có
thể được thỏa mãn với các tài nguyên còn tự do của hệ thống, cộng với các tài nguyên
đang bị chiếm giữ bởi các tiến trình Pj khác, với j<i.
Một trạng thái an toàn không thể là trạng thái tắc nghẽn. Ngược lại một trạng thái
không an toàn có thể dẫn đến tình trạng tắc nghẽn.
Chiến lược cấp phát : ch
ỉ thỏa mãn yêu cầu tài nguyên của tiến trình khi trạng thái
kết quả là an toàn!
Giải thuật xác định trạng thái an toàn
Cần sử dụng các cấu trúc dữ liệu sau :
int Available[NumResources];

P4 4 2 2 0 0 2
Nếu tiến trình P2 yêu cầu 4 cho R1, 1 cho R3. hãy cho biết yêu cầu này có thể đáp ứng
mà bảo đảm không xảy ra tình trạng deadlock hay không ? Nhận thấy Available[1] =4,
Available[3] =2 đủ để thõa mãn yêu cầu của P2, ta có
Need Allocation Available
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 2 2 2 1 0 0
P2 0 0 1 6 1 2
P3 1 0 3 2 1 1
P4 4 2 0 0 0 2
Need Allocation Available
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 2 2 2 1 0 0
P2 0 0 0 0 0 0
P3 1 0 3 2 1 1
P4 4 2 0 0 0 2
Need Allocation Available
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 0 0 0 0 0 0
P2 0 0 0 0 0 0
P3 1 0 3 2 1 1
P4 4 2 0 0 0 2
Need Allocation Available
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 0 0 0 0 0 0
P2 0 0 0 0 0 0
P3 0 0 0 0 0 0
P4 4 2 0 0 0 2
Need Allocation Available
R1 R2 R3 R1 R2 R3 R1 R2 R3

Giải thuật phát hiện tắc ngh
ẽn
1. int Work[NumResources] = Available;
int Finish[NumProcs];

for (i = 0; i < NumProcs; i++)
Finish[i] = (Allocation[i] == 0);

2. Tìm i sao cho
Finish[i] == false
Request[i] <= Work
Nếu không có i như thế, đến bước 4.

3. Work = Work + Allocation[i];
Finish[i] = true;
Đến bước 2

4. Nếu Finish[i] == true với mọi i,
thì hệ thống không có tắc nghẽn
Nếu Finish[i] == false với một số giá trị i,
thì các tiến trình mà Finish[i] == false sẽ ở
trong
tình trạng tắc nghẽn.
II.8. Hiệu chỉnh tắc nghẽn
Khi đã phát hiện được tắc nghẽn, có hai lựa chọn chính để hiệu chỉnh t
ắc nghẽn :
Đình chỉ hoạt động của các tiến trình liên quan
Cách tiếp cận này dựa trên việc thu hồi lại các tài nguyên của những tiến trình bị kết thúc.
Có thể sử dụng một trong hai phương pháp sau :
Đình chỉ tất cả các tiến trình trong tình trạng tắc nghẽn

Bỏ qua tắc nghẽ
n : xem như hệ thống không bao giờ lâm vào trạng thái
tắc nghẽn.
Củng cố bài học
Các câu hỏi cần trả lời được sau bài học này :
1. Phân biệt nhóm giải pháp busy waiting và Sleep&Wakeup
2. Phân biệt cách sử dụng semaphore, monitor và message để đồng bộ hoá.
3. Mô hình giải quyết nhu cầu độc quyền truy xuất và mô hình giaỉ quyết nhu cầu phối
hợp hoạt động.
Bài tập
Bài 1. Xét giải pháp phần mềm do Dekker đề nghị để tổ chức truy xất độc quyền cho
hai tiến trình . Hai tiến trình P
0
, P
1
chia sẻ các biến sau :
var flag : array [0 1] of boolean; (khởi động là false)
turn : 0 1;
Cấu trúc một tiến trình Pi ( i =0 hay 1, và j là tiến trình còn lại ) như sau :
repeat
flag[i] := true;
while flag[j] do
if turn = j then
begin
flag[i]:= false;
while turn = j do ;
flag[i]:= true;
end;
critical_section();
turn:= j;

Giải pháp này có phải là một giải pháp đúng thỏa mãn 4 yêu cầu không ?
Bài 3.Xét giải pháp đồng bộ hoá sau :
while (TRUE) {
int j = 1-i;
flag[i]= TRUE; turn = i;
while (turn == j && flag[j]==TRUE);
critical-section ();
flag[i] = FALSE;
Noncritical-section ();
}
Đây có phải là một giải pháp bảo đảm được độc quyền truy xuất không ?
Bài 4.Giả sử một máy tính không có chỉ thị TSL, nhưng có chỉ thị Swap có khả năng
hoán đổi nội dung của hai từ nhớ chỉ bằng một thao tác không thể phân chia :
procedure Swap() var a,b: boolean);
var temp : boolean;
begin
temp := a;
a:= b;
b:= temp;
end;
Sử dụng ch
ỉ thị này có thể tổ chức truy xuất độc quyền không ? Nếu có xây dựng cấu trúc
chương trình tương ứng.
Bài 5.Chứng tỏ rằng nếu các primitive Down và Up trên semaphore không thực hiện
một cách không thể phân chia, thì sự truy xuất độc quyền sẽ bị vi phạm.
Bài 6.Sử dụng semaphore để cài đặt cơ chế monitor.
Bài 7.Xét hai tiến trình sau :
process A
{ while (TRUE)
na = na +1;

2
}
Đồng bộ hoá hoạt động của hai tiến trình này sao cho cả A
1
và B
1
đều hoàn tất trước khi
A
2
hay B
2
bắt đầu .
Bài 10.Tổng quát hoá câu hỏi 8) cho các tiến trình xử lý đoạn chương trình sau :
process P
1
{ for ( i = 1; i <= 100; i ++) Ai }
process P
2
{ for ( j = 1; j <= 100; j ++) Bj }
Đồng bộ hoá hoạt động của hai tiến trình này sao cho cả với k bất kỳ ( 2 ≤ k ≤ 100), Ak

chỉ có thể bắt đầu khi B
(k-1)
đã kết thúc, và Bk

chỉ có thể bắt đầu khi A
(k-1)
đã kết thúc.
Bài 11.Sử dụng semaphore để viết lại chương trình sau theo mô hình xử lý đồng hành:
w := x1 * x2

a) Lưu ý là trên bàn chỉ có 5 cái nĩa, và nếu có 2 triết gia cùng muốn lấy một cái nĩa, thì
chỉ một người được quyền lấy cái nĩa đó. Sử dụng semaphore để tổ chức độc quyền truy
xuất đến các cái nĩa cho đoạn chươ
ng trình trên ( Gợi ý : dùng mỗi semaphore phản ánh
tình trạng sử dụng của mỗi cái nĩa)
b) Liệu giải pháp của câu a) có là một giải pháp tốt cho bài toán Dining philosopher?Nếu
không, cho biết các tình huống lỗi sẽ xảy ra, và đề nghị phương pháp cải tiến.
Bài 14.Xét một giải pháp đúng cho bài toán Dining philosophers :
#define N 5
#define LEFT (i-1)%N
#define RIGHT (i+1)%N
#define THINKING 0
#define HUNGRY 1
#define EATING 2
int state[N];
semaphore mutex = 1;
semaphore s[N];
void philosopher( int i) // i : xác định triết gia nào (0 N-1)
{
while (TRUE)
{ thinhk(); // Suy nghĩ
take_forks(i); // yêu cầu đến khi có đủ 2 nĩa
eat(); // yum-yum, spaghetti
put_forks(i); // đặt cả 2 nĩa lên bàn lại
}
}
void take_forks ( int i) // i : xác định triết gia nào (0 N-1)
{
while (TRUE)
{ down(mutex); // vào miền găng

100 triết gia?
Bài 15.Xây dựng giải pháp monitor cho bài toán Dining Philosophers.
Bài 16.Baber problem
: Một cửa hiệu cắt tóc có một thợ, một ghế cắt tóc và N ghế cho
khách đợi. Nếu không có khách hàng, anh thợ cắt tóc sẽ ngồi vào ghế cắt tóc và ngủ thiếp
đi. Khi một khách hàng vào tiệm, anh ta phải đánh thức người thợ. Nếu một khách hàng
vào tiệm khi người thợ đang bận cắt tóc cho kh1ch hàng khác, người mới vào sẽ phải
ngồi chờ nếu có ghế đợi trống, hoặc rời khỏ
i tiệm nếu đã có N người đợi. Xây dựng một
giải pháp với semaphore để thực hiện đồng bộ hoá hoạt động của thợ và khách hàng
trong cửa hiệu cắt tóc này.
/* Semaphore to protect critical sections */
Semaphore mutex = 1;

/* Semaphore for the number of waiting customers.
* This lets the barber go to sleep when there are no
customers */
Semaphore customers = 0;

/* Number of waiting customers in the barber shop */
/* Just used to turn away customers when there are too many
already. */
int waiting_customers = 0

/* Semaphore on which to wait for a haircut */
Semaphore haircut = 0;

/* Customer calls this function to try to get their hair
cut
* it returns true if the hair gets cut. */