Chuong 5. Dong Bo Hoa Tien Trinh - Ver4

Nguyên Lý Hệ Điều Hành
Chương 5
ĐỒNG BỘ HÓA CÁC TIẾN TRÌNH
Khoa Công nghệ Thông tin

Trường Đại học Thủ Dầu Một
Nội dung chương
 Thảo luận
 Ví dụ đồng bộ hóa
 Miền găng (critical section)
 Các giải pháp đồng bộ
 Các vấn đề về đồng bộ hóa.
2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 2

1/4
Ví dụ đồng bộ hóa
• Tiến trình ghi P1: • Tiến trình đọc P2:
while (true){ while (true){
while (counter ==SIZE) while (counter ==0)
; /*không làm gì cả*/ ; /*không làm gì cả*/
buf[in] = next_Item; next_Item = buf[out];
in = (in+1) % SIZE; out = (out+1) % SIZE;
Counter++; Counter--;
} }
• Buf: Buffer
• SIZE: cỡ của buffer Đây là bài toán vùng
đệm có giới hạn
• counter: biến chung
2/4
• Các phát biểu counter++ và counter– được xây
dựng như sau
• Counter++ • Counter--
register1 = counter; register2 = counter;
register1 = register1 + 1; register2 = register2 - 1;
counter = register1; counter = register2;
• P1 và P2 có thể nhận được counter có giá trị khác

nhau tại cùng một thời điểm nếu như đoạn mã
counter++ và counter-- thực hiện xen kẽ nhau.
3/4
• Giả sử P1 và P2 thực hiện song song với
nhau và giá trị của counter là 5:
register1 = counter; //register1 = 5
register1 = register1 + 1; //register1 = 6
register2 =register2 -1; //register2 = 4
counter = register1; //counter = 6 ??
counter = register2; //counter = 4 ??
Lỗi: Cho phép P1 & P2 đồng thời thao
tác trên biến chung counter.
4/4
• Sửa lỗi:
register1 = register1 + 1; //register1 = 6
counter = register1; //counter = 6
register2 =register2 -1; //register2 = 5
counter = register2; //counter = 5

1/3
Tại sao phải đồng bộ hóa ?
Tình huống: Trong hệ đa chương, thường có nhiều
process chạy song hành.
 Nếu 2 hay nhiều process cần giao tiếp nhau để trao đổi dữ
liệu cần truy xuất bộ nhớ dùng chung.
Tranh đoạt tài nguyên

2/3
Tại sao phải đồng bộ hóa ?
Ghi
P1 Dữ liệu P1 ghi vào
Đọc A, bị P2 ghi đè.
A A A
Đọc
P2
Ghi
t0 t1 t2 time
• Truy xuất đồng thời vào vùng dữ liệu dùng chung có
thể tranh chấp với process khác  có thể gây ra sự
mâu thuẫn dữ liệu  cần kiểm soát.
3/3
Tương tranh và đồng bộ
• Tình huống xuất hiện khi nhiều tiến trình
cùng thao tác trên dữ liệu chung và kết
quả các thao tác đó phụ thuộc vào thứ tự
thực hiện của các tiến trình trên dữ liệu
chung đó gọi là tình huống tương tranh (race
condition)
• Để tránh các tình huống tương tranh, các tiến
trình cần được đồng bộ theo một phương
thức nào đó  cần giải pháp đồng bộ hóa
các tiến trình

1/2
Đồng bộ hóa các tiến trình
Khái niệm: là bảo đảm các tiến trình xử lý song song
không tác động sai lệch đến nhau. Thực hiện hai yêu cầu
sau:
 Yêu cầu độc quyền truy xuất (Mutual exclusion):
tại một thời điểm, chỉ có một tiến trình được quyền
truy xuất một tài nguyên không thể chia sẻ.
 Yêu cầu phối hợp (Synchronization): các tiến trình
cần hợp tác với nhau để hoàn thành công việc.

2/2
Đồng bộ hóa các tiến trình
Ví dụ 1: Hai tiến trình phối hợp với nhau như một chương trình in.
 Xuất kí tự vao buffer.
 Kí tự được lấy và in bởi chương trình điều khiển máy in
(printer driver).
Không được xuất kí tự vào buffer khi buffer đầy mà phải chờ printer
driver lấy bớt dữ liệu.
 Giải quyết 2 bài toán

 “Độc quyền truy xuất” (miền găng).
 “Phối hợp thực hiện”

1/5
Miền găng (Critical Section)
 Đoạn mã của một tiến trình có khả năng xảy ra lỗi khi
truy xuất tài nguyên dùng chung (biến, tập tin,…) được
gọi là miền găng.
 Gọi tắc CS
Ví dụ 2: giả sử có hai tiến trình P1 và P2 sử dụng:
– Taikhoan : biến dùng chung
– Mỗi tiến trình muốn rút tiền từ tài khoản bằng đoạn mã
sau:
if (taikhoan – tienrut >=0)
taikhoan= taikhoan – tienrut;
Else error(“khong the rut tien”);
2/5
• Ví dụ 2:
– Hiện tại, Taikhoan = 800.
– Tình huống
 P1 muốn rút = 500, P2 muốn rút 400.
 HĐH cấp CPU cho P1: kiểm tra ĐK (800>=500) đúng , hết
thời gian sử dụng CPU.
 HĐH cấp CPU cho P2: kiểm tra ĐK (800>=400) đúng
– Cập nhật Taikhoan = 800-400 = 400, hết TG sử dụng
CPU.
 HĐH cấp CPU cho P1
– Cập nhật Taikhoan = 400-500 = -100  lỗi dữ liệu
if (taikhoan – tienrut >=0)

taikhoan= taikhoan – tienrut;
là một miền găng

3/5
• Ví dụ 3: Ví dụ hai tiến trình A và B chạy trên hai bộ xử lý, cùng ghi
dữ liệu vào một hàng đợi dùng chung có thể xảy ra lỗi.
Thời gian
Tiến trình A Tiến trình B
.
Tới cuối hàng đợi thêm dữ .
liệu vào vị trí này .
.
. Tới cuối hàng đợi
. .
Tăng giá trị con trỏ cuối .
.
hàng đợi
. Thêm dữ liệu vào vị trí của con trỏ /*LỖI*/
. Tăng giá trị con trỏ cuối hàng đợi
.
.
.
.
• Quản lý sự toàn vẹn dữ liệu: yêu cầu các cơ chế để đảm bảo việc
phối hợp của các tiến trình một cách có thứ tự.

4/5
 Quản lý sự toàn vẹn dữ liệu: yêu cầu các cơ chế để đảm bảo
việc phối hợp của các tiến trình một cách có thứ tự.
Thời gian A vào CS A ra khỏi CS
Tiến trình A
B cố gắng vào B ra khỏi
B vào CS CS
CS
Tiến trình B
T1 T2 B bị khóa T3 T4 Time
 A trong CS
 Nếu B muốn vào CS: B sẽ bị khoá chờ A ra khỏi CS  B
mới được vào CS.
5/5
Khi giải quyết bài toán CS chú ý 4 điều kiện sau:
(1) Không có hai tiến trình cùng ở trong CS cùng lúc.
(2) Không có giả thiết về tốc độ của các tiến trình, cũng
như về số lượng bộ xử lý.
(3) Một tiến trình bên ngoài CS không được ngăn cản các
tiến trình khác vào CS.
(4) Không có tiến trình nào phải chờ vô hạn để được vào
CS.

Các giải pháp đồng bộ
Chia làm 2 nhóm tùy theo cách tiếp cận trong xử lý tiến
trình bị khóa:
 Nhóm giải pháp “busy waiting”
• Các giải pháp phần mềm
• Các giải pháp phần cứng
 Nhóm giải pháp “sleep and wakeup”
• Semaphore
• Monitors
• Trao đổi thông điệp

Nhóm giải pháp “busy waiting”
 Các giải pháp phần mềm
 Thuật toán 1
 Thuật toán 2
 Peterson
 Các giải pháp phần cứng
 Cấm ngắt
 Dùng chỉ thị TSL

1/7
Giải pháp phần mềm
 Thuật toán 1: sử dụng cờ hiệu
 Ý tưởng: Các tiến trình dùng chung biến cờ hiệu lock
nhận 1 trong 2 giá trị (0- không có process trong CS hoặc
1- có process trong CS)
lock = 0;
while (TRUE){ //một tiến trình có thể truy xuất CS nhiều lần
while (lock ==1); //Nếu lock = 1, có 1 process trong CS, đợi.
lock = 1; // Trước khi vào CS gán lock =1 , để không cho các
process khác vào CS
critical_section(); // Miềng găng (CS)
lock = 0; // Cho phép các tiến trình khác vào CS

noncritical-section(); // Đoạn mã không phải CS
}

2/7
 Thuật toán 1: sử dụng cờ hiệu
 Thảo luận
 Vi phạm ĐK nào? Khi giải bài toán về CS. Tình huống
?
 Nhận xét:
• Vi phạm ĐK (1) là hai tiến trình có thể cùng ở trong
CS tại một thời điểm.

3/7
 Thuật toán 2: sử dụng kiểm tra luân phiên
 Ý tưởng: Hai tiến trình A, B sử dụng chung biến turn
 turn =0, tiến trình A được vào CS
 turn=1 thì B được vào CS .
 khởi tạo: turn = 0, tức là A được vào trước
 Hai tiến trình A,B được cài đặt như sau

4/7
Process A
while (TRUE){
while (turn ==1); // Wait //neu turn=1 thi A vao vong while de doi
critical_section(); //neu turn=0 thi A được vào CS
turn = 1; //Cho phép B vào CS
noncritical-section();
}
Process B
while (TRUE){
while (turn ==0); // Wait //neu turn=0 thi B vao vong while de doi
critical_section(); //neu turn=1 thi B được vào CS
turn = 0; //Cho phép A vào CS
noncritical-section();
}

5/7
 Thảo luận
 Vi phạm ĐK nào? khi giải bài toán về CS. Tình huống ?
 Nhận xét:
• Thỏa ĐK (1)
• Vi phạm ĐK (3) một tiến trình có thể bị ngăn chặn vào
CS bởi một tiến trình khác không ở trong CS.
− Khi tiến trình A đang ở trong phần Noncritical-section(). Thì
tiến trình B không thể vào CS hai lần liên tiếp
• GP này phụ thuộc vào tốc độ thực hiện của hai tiến
trình,  vi phạm ĐK (2)

6/7
 Thuật toán Peterson: kết hợp 2 giải pháp trên
 Ý tưởng: Hai tiến trình P0, P1 dùng chung 2 biến turn và flag[2]
 Flag[i] = TRUE (i=0,1) có nghĩa là tiến trình Pi muốn vào CS
 Turn = i là đến lượt Pi
 Khởi tạo: flag[0] = flag[1]= FALSE và turn = 0 hay 1
// tiến trình P0 (i=0) // tiến trình P1 (i=1)
while (TRUE) while (TRUE)
{ {
flag [0]= TRUE;//P0 thông báo muốn vào CS flag [1]= TRUE;//P1 thông báo muốn vào CS
turn = 1; //Đề nghi P1 vào turn = 0; //Đề nghi P0 vào
//Nếu P1 muốn vào thì P0 chờ, dùng while //Nếu P0 muốn vào thì P1 chờ, dùng while
while (turn == 1 && flag [1]==TRUE); while (turn == 0 && flag [0]==TRUE);
critical_section(); ;//P0 vào CS critical_section(); ;//P1 vào CS
flag [0] = FALSE; //P0 ra ngoài CS flag [1] = FALSE; //P1 ra ngoài CS
noncritical_section (); noncritical_section ();
} }

7/7
 Thuật toán Peterson: kết hợp 2 giải pháp trên
 Nhận xét:
– Nếu cả hai tiến trình đều muốn vào CS thì flag[0] = flag[1]
=TRUE
– Nhưng giá rị của turn tại một thời điểm chỉ có thể hoặc là 0
hoặc là 1, do vậy chỉ có một tiến trình được vào CS
Thỏa tất cả các điều kiện.
– Phức tạp khi số lượng tiến trình tăng lên
– Khó kiểm soát

1/3
Giải pháp phần cứng
 Cấm ngắt
 Tiến trình cấm tất cả các ngắt trước khi vào CS, và phục hồi
ngắt khi ra khỏi CS
 Khi đó ngắt đồng hồ cũng không thể xảy ra  HT không thể
tạm dừng hoạt động của tiến trình đang xử lý để cấp phát CPU
cho tiến trình khác  không sợ bị tranh chấp CS.
 Nhận xét:
 Dễ cài đặt nhưng cấm tất cả các ngắt là nguy hiểm
 HT có nhiều bộ xử lý: lệnh cấm ngắt chỉ có tác dụng trên bộ
xử lý đang xử lý tiến trình  các tiến trình hoạt động trên
các bộ xử lý khác vẫn có thể truy xuất đến CS.

2/3
 Sử dụng chỉ thị TSL (Test and Set Lock)
 Đa số phần cứng cung cấp lệnh TSL cho phép kiểm tra và cập
nhật một vùng nhớ trong một thao tác độc quyền.
 Nếu có hai lệnh TSL xử lý đồng thời trên hai CPU khác nhau thì
chúng sẽ được xử lý tuần tự.
 Lệnh TSL có cấu trúc như sau
boolean Test_And_Set_Lock (boolean lock)
{
boolean temp=lock;
lock = TRUE;
return temp; //trả về giá trị ban đầu của biến lock
}

3/3
 Sử dụng chỉ thị TSL (Test and Set Lock)
 Cài đặt tiến trình truy xuất độc quyền với TSL dùng biến dùng
chung lock
 Lock = FALSE tiến trình có thể vào CS
 Khởi tạo: Lock = FALSE
boolean lock=FALSE; //biến dùng chung
while (TRUE)
{
while (Test_And_Set_Lock(lock));
critical_section ();
lock = FALSE;
noncritical_section ();
}

Nhận xét “busy waiting”
 Nhóm giải pháp “busy waiting” đều phải thực hiện
một vòng lặp để kiểm tra xem có được vào CS hay
không.
tiến trình đang chờ vẫn chiếm dụng CPU.
 Xu hướng: cần tránh các giải pháp “busy waiting”

1/3
Nhóm giải pháp SLEEP and WAKEUP
 Hệ điều hành cung cấp hai lệnh:
 Lệnh SLEEP: HĐH sẽ chuyển tiến trình sang “ready queue”,
lấy lại CPU cấp cho tiến trình khác.
 Lệnh WAKEUP: HĐH sẽ chọn một tiến trình trong ready
queue, cho thực hiện tiếp.
 Khi một tiến trình chưa đủ điều kiện vào CS, nó gọi SLEEP để
tự khóa, đến khi có một tiến trình khác gọi WAKEUP để giải
phóng cho nó.

2/3
 Ví dụ: chương trình giải quyết CS
//busy và blocked là hai biến dùng chung.
int busy=FALSE; // TRUE là có tiến trình trong CS, FALSE là không có tiến trình
trong CS
int blocked=0; // đếm số lượng tiến trình đang bị khóa
while (TRUE) //để cho một tiến trình có thể vào CS nhiều lần
{
if (busy)  Các hành động kiểm tra biến
{ blocked = blocked + 1; busy và gọi sleep() là tách biệt
sleep(); } có thể bị ngắt giữa chừng.
else busy = TRUE;
 Có thể tín hiệu Wakeup gởi đến
critical-section ();
1 tiến trình chưa bị khoá sẽ mất
busy = FALSE;
if (blocked>0) liên lạc.
{ wakeup(); //đánh thức một tiến trình đang chờ
blocked = blocked - 1; }
Noncritical-section ();
}
3/3
 Nhận xét
 Có thể có trường hợp 2 tiến trình cùng nằm trong CS (vi phạm
điều kiện 1)
 Có thể có một tiến trình ngoài CS ngăn chặn tiến trình vào CS
(vi phạm điều kiện 3)
 Để tránh những khả năng vi phạm này, hệ điều hành cấp những
cơ chế đồng bộ hóa như Semaphore, Monitor dựa trên ý tưởng
của chiến lược “SLEEP and WAKEUP” nhưng việc kiểm tra
điều kiện vào CS và việc chờ được xây dựng thành hành động
độc quyền, giúp việc giải quyết bài toán CS an toàn, hiệu qủa
hơn.

1/6
Semaphore
 Semaphore là cấu trúc được Dijkstra đề xuất vào 1965
class semaphore
{
int e;
PCB * f; //ds các khối PCB của các tiến trình đang
chờ trên semaphore
public:
down();
up();
};
 |e| = số tiến trình đang chờ trên f.

2/6
Semaphore
 s là một biến kiểu Semaphore, s có các thuộc tính sau:
− Một giá trị nguyên dương e
− Một hàng đợi f lưu danh sách các tiến trình đang chờ trên
semaphore s
− Có hai thao tác được định nghĩa
 Down(s): e=e-1. Nếu e < 0 thì tiến trình phải chờ trong f, ngược lại
tiến trình tiếp tục.
 Up(s): e=e+1. Nếu e<=0 thì chọn một tiến trình trong f cho tiếp tục
thực hiện (đánh thức)
− Down và Up cần được cài đặt độc quyền
 Có thể dùng cấm ngắt (1 CPU) hoặc TSL (nhiều CPU) để cài đặt
 Nếu dùng giải pháp phần mềm thì Semaphore  giải thuật “busy
and waiting” nhưng tách vòng lặp chờ ra khỏi chương trình.

3/6
Semaphore
 P là tiến trình thực hiện thao tác Down(s) hay Up(s)
Down(s)
{ e = e - 1;
if (e < 0)
{ status(P)= blocked; //chuyển P sang trạng thái bị khoá (chờ)
enter(P,f); //cho P vào hàng đợi f }
}
Up(s)
{ e = e + 1;
if (e<= 0 )
{ exit(Q,f); //lấy một tiến trình Q ra khỏi hàng đợi f
status (Q) = ready; //chuyển Q sang trạng thái sẵn sàng
enter(Q,ready-queue); //đưa Q vào hàng đợi sẵn sàng của hệ thống }
}

4/6
Truy xuất độc quyền với Semaphores
 N tiến trình dùng một semaphore s, e được khởi gán là 1
 Tất cả các tiến trình có cùng cấu trúc sau:
semaphore s=1; //nghĩa là e của s=1
while (TRUE)
{
Down(s);
Up(s);
}

5/6
Đồng bộ hóa với Semaphores
 Ví dụ: có hai tiến trình đồng hành P1 và P2, P1 thực hiện công
việc 1, P2 thực hiện công việc 2.
 Giả sử muốn cv1 làm trước rồi mới làm cv2
 Hai tiến trình dùng chung một semaphore s, khởi gán e(s)= 0
semaphore s=0;
P2:
P1:
{
{
While (TRUE)
While (TRUE)
{
{
Down(s); // chờ P1 đánh thức
job1();
job2();
Up(s); //đánh thức P2
}
}
}
}

6/6
Đồng bộ hóa với Semaphores
• Nhận xét
– Nhờ lệnh down, up là độc quyền, semaphore đã giải
quyết được vấn đề tín hiệu "đánh thức" bị thất lạc.
– Tuy nhiên sử dụng semaphore cũng không đơn giản,
chương trình dễ bị lỗi mà không dự đoán được. Một
số tình huống gây ra lỗi:
 Nếu đặt Down và Up sai vị trí hoặc thiếu thì có thể bị sai. Ở
ví dụ 2, nếu P1 để Up() lên trước lệnh job1() thì nếu P1
thực hiện trước P2, có thể job1 chưa thực hiện xong mà
job2 được thực hiện.
 Có thể gây ra tắc nghẽn
 Có thể gây ra tình trạng đói CPU khi giải thuật chọn tiến
trình đang đợi là giải thuật LIFO

1/7
Monitor
 Thuật ngữ monitor: giám sát
 Định nghĩa không hình thức: là một loại cấu trúc
(construct) trong ngôn ngữ bậc cao dùng để phục vụ các
thao tác đồng bộ hóa
 Monitor được nghiên cứu, phát triển để khác phục các
hạn chế của semaphore, dễ viết đúng các chương trình
đồng bộ hóa hơn.
 Được cung cấp bởi ngôn ngữ lập trình Monitor

2/7
Monitor
 Monitor là một cấu trúc đặt biệt (Lớp) bao gồm các
phương thức độc quyền, các biến và cấu trúc dữ liệu
 Các biến và cấu trúc dữ liệu trong monitor chỉ có thể được
truy xuất bởi các phương thức trong monitor . Là các biến
dùng chung cho các tiến trình (encapsulation)
 Tại một thời điểm, chỉ có một tiến trình duy nhất được hoạt
động bên trong một monitor. (mutual exclusive)
 Trong 1 monitor có thể khai báo các biến điều kiện và 2 thao
tác Wait() và Signal()
• Wait(c): chuyển trạng thái tiến trình gọi sang blocked và
đặt tiến trình này vào hàng đợi trên biến điều kiện c.
• Signal(c): Nếu một tiến trình đang chờ trong hàng đợi của
c, tái kích hoạt tiến trình đó và tiến trình sẽ rời khỏi
monitor.

3/7
Monitor
 Trình biên dịch truy xuất độc quyền dữ liệu trên Monitor.
Wait(c)
{
status(P)= blocked; //chuyển P sang trạng thái chờ
enter(P,f(c)); //đặt P vào hàng đợi f(c) của biến điều kiện c
}
Signal(c)
{
if (f(c) != NULL)
{ exit(Q,f(c)); //Lấy tiến trình Q đang chờ trên c
statusQ) = ready; //chuyển Q sang trạng thái sẵn sàng
enter(Q,ready-queue); //đưa Q vào hàng đợi sẵn sàng.
}
}

4/7
Mô hình cấu trúc Monitor
 Mỗi biến kiểu monitor có có một hàng đợi toàn cục lưu các tiến
trình đang chờ được sử dụng monitor.
 Dùng chung cho các tiến trình chia sẻ tài nguyên chung
Hàng đợi vào monitor
Dữ liệu chung
b P1
c P2 P5
Procedure 1
Procedure N
Khởi tạo

5/7
Cài đặt Monitor
 //Khai báo monitor dùng chung cho các tiến trình
monitor <tên monitor>
{
<Các biến dùng chung>;
<Các biến điều kiện>;
<Các phương thức độc quyền>;
}

6/7
Cài đặt Monitor
 //Tiến trình Pi sử dụng monitor
while (1) //cấu trúc tiến trình thứ i
{
<ten monitor>.Phươngthức_i; //thực hiện công việc độc
quyền thứ i
}

7/7
Nhận xét
 Việc truy xuất độc quyền được đảm bảo bởi trình biên
dịch mà không do lập trình viên.
 Đòi hỏi ngôn ngữ lập trình đang sử dụng phải có kiểu dữ
liệu là monitor.

1/3
Sử dụng thông điệp (message)
 Có một tiến trình kiểm soát tài nguyên và nhiều tiến trình khác yêu
cầu tài nguyên.
 Tiến trình yêu cầu tài nguyên sẽ gởi 1 thông điệp đến tiến trình
kiểm soát tài nguyên → chuyển sang trạng thái blocked .
 Tiến trình kiểm soát nhận message, khi tài nguyên sẳn sàng thì gởi
một message khác đến tiến trình đang đợi → đánh thức và cho sử
dụng tài nguyên.
 Khi sử dụng xong tài nguyên, tiến trình sử dụng tài nguyên gởi một
message đến tiến kiểm soát để bào kết thúc.

2/3
Sử dụng thông điệp (message)
Cấu trúc tiến trình yêu cầu tài nguyên
while (TRUE)
{ //Gửi message yêu cầu t.nguyên và chuyển sang trạng thái blocked
Send(process controler, request message);
//Nhận message chấp nhận sử dụng tài nguyên
Receive(process controler, accept message);
//Độc quyền sử dụng tài nguyên dùng chung
//Gửi message kết thúc sử dụng tài nguyên.
Send(process controler, end message);
} 2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 48
3/3
Thảo luận
Semaphore và monitor: truy xuất độc quyền trên máy
tính có 1 hoặc nhiều CPU chia sẻ 1 vùng nhớ chung;
không hữu hiệu trong hệ phân tán.
Trao đổi thông điệp: hữu hiệu trong hệ phân tán.

1/3
Bài tập 1
• Một biến X được chia sẻ bởi hai tiến trình
cùng thực hiện đoạn code sau :
Do {
X = X + 1;
If (X==20) X = 0;
} While (TRUE);
• Bắt đầu với giá trị X = 0, chứng tỏ rằng giá trị
X có thể vượt quá 20. Cần sửa chữa đoạn
chương trình trên như thế nào để bảo đảm X
không vượt quá 20?

2/3
Bài tập 2
• Xét hai tiến trình xử lý đoạn chương trình
sau:
– process P1 { A1 ; A2 }
– process P2 { B1 ; B2 }
• Ðồng bộ hóa hoạt động của hai tiến trình này
sao cho cả A1 và B1 đều hoàn tất trước khi
A2 hay B2 bắt đầu.

3/3
Bài tập 3
• Quy trình sản xuất ô tô của một hãng xe có 3 bộ phận
hoạt động song song :
– Bộ phận sản xuất 1 khung xe :
MakeChassis() { Produce_chassis(); // tạo khung xe }
– Bộ phận sản xuất 1 bánh xe :
MakeTires() { Produce_tire();// tạo bánh xe }
– Bộ phận lắp ráp:
Assemble() { Put_4_tires_to_Chassis(); //gắn 4 bánh
xe vào khung xe }
• Hãy đồng bộ hoạt động trong việc sản xuất xe hơi theo
nguyên tắc sau :
– Tại một thời điểm chỉ cho phép sản xuất một khung xe,
– cần có đủ 4 bánh xe cho 1 khung xe được sản xuất ra, sau đó
mới tiếp tục sản xuất khung xe khác.

Chuong 5. Dong Bo Hoa Tien Trinh - Ver4

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chuong 5. Dong Bo Hoa Tien Trinh - Ver4

Uploaded by

Copyright:

Available Formats

Nguyên Lý Hệ Điều Hành

Khoa Công nghệ Thông tin

 Miền găng (critical section)

 Các giải pháp đồng bộ

 Các vấn đề về đồng bộ hóa.

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 2

• P1 và P2 có thể nhận được counter có giá trị khác

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 6

Tranh đoạt tài nguyên

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 7

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 9

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 10

 Giải quyết 2 bài toán

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 11

if (taikhoan – tienrut >=0)

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 13

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 14

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 16

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 17

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 18

lock = 0; // Cho phép các tiến trình khác vào CS

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 19

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 20

 Hai tiến trình A,B được cài đặt như sau

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 21

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 22

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 23

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 24

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 25

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 26

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 27

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 28

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 29

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 30

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 32

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 33

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 34

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 35

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 37

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 38

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 39

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 40

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 41

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 42

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 43

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 44

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 45

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 46

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 47

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 49

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 50

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 51

2/2016 Chương 5. Đồng bộ hóa các Tiến Trình 52

You might also like