WAIT and SIGNAL strict WaitSignalVar { Boolean lock; proceesQueue queue; }; Void Wait(WaitSignalVar var) { If (TestAndSet(var.lock)) Var.ProcessQuere.Insert(); } Void Signal(WaitSigntVar var) { Var.ProcessQuere.Remove(); Var.lock=false; } Chú ý: Hàm Insert() đặt tiến trình vào hang đợi và gán trạng thái tiến trình thành bị chặn. Hàm Remove() chọn tiến trình trong hang đợi và gán trạng thái từ bị chặn trở thành sẵn sàng. SEMAPHORE Struct semaphore { Int count; ProcessQuere queue; }; Void P(semaphore s) //proveren: to test { If (s.count > 0) s.count=s.count -1; else s.quere.Insert(); // block this process } Void V(semaphore s) { If (s.quere.empty()) s.count=s.count + 1; else s.quere.Remove(); } SEMAPHORE nhị phân Void P(semaphore s) //proveren: to test { If (s.count ==1) s.count=0; else s.quere.Insert(); // block this process } Void V(semaphore s) { If (s.quere.empty()) s.count= 1; else s.quere.Remove(); } Sử dụng cấu trúc SEMAPHORE để giải quyết vấn đề Mutual Exclusion( loại trừ tương hỗ) Share semaphore s=1; // ……. P(s); // Critical Section V(s); Gán biến s=1 . Trước khi vào vùng tranh chấp, gọi hàm P(s), và sau khi ra khỏi vùng tranh chấp thì gọi hàm V(s) BÀI TẬP Cho hàm TestAndSet sau: Boolean testAndSet( Boolean locked) { If (locked) Return true; Else { Locked=true; Return false; } } a)Cho các tiến trình sử dụng TestAndSet như sau: share Boolean lock=false; //……. While (TestAndSet(lock)) DoNoThing(); // Critical-Section Lock=false; Hãy chứng minh giải pháp TestAndSet thỏa mãn tính loại trừ tương hỗ(Mutual Exclucsion). Hãy cho vd với 3 tiến trình P1, P2, P3. Giải Giải pháp dùng TestAndSet trong trường hợp này cho thấy khi tiến trình nào đó muốn vào vùng tranh chấp thì nó thực hiện hàm TestAndSet : hàm trả về false làm cho tiến trình bỏ qua vòng While, đồng thời gán lock=true để khóa các tiến trình khác không vào miền găng. Nếu tiến trình nào đó muốn vào miền găng(vùng tranh chấp) thì do lock=true nên vòng While bắt tiến trình đó phải chờ(do hàm TestAndSet trả về true) VÍ DỤ: P1 P2 P3  Do lock=true nên P1 thực hiện vòng While để chờ vào miền găng  Lock=false  Thực hiện hàm TestAndSet trả về false, thoát khỏi while và vào miền găng, đồng thời gán lock=true( ngụ ý khóa các tiến trình P1,P3 vào miền găng)  Khi P2 ra khỏi miền găng, nó gán lock=false  Do lock=true nên P3 thực hiện vòng While để chờ vào miền găng  Khi lock=false nên hàm TestAndSet sẽ return về false làm cho P3 không còn chờ nữa(thoát While) và vào miền găng  Gán lock=true để khóa P1 và P2 vào miền găng BÀI TẬP SEMAPHORE 1)Cho các thao tác P,V như sau: Void P(semaphore s) { if (s.count==1) s.count=0; else s.queue.Insert();//block this process } Void V(semaphore s) { If (s.queue.empty()) s.count=1; else s.queue.remove();//schedule a process } Share semaphore s=1; // P(s); Critical-Section; V(s); Chứng minh các tiến trình thỏa mãn yêu cầu mutual-exclusion. 2)Cho cấu trúc SWAP như sau: Void swap(Boolean a, Boolean b) { Boolean temp; temp=b; b=a; a =temp; } Shared boolean lock=false; Boolean key; //…. Key=true; Do Swap(lock,key); While (key); //critical-section; Lock=false; a)Hãy sử dụng chỉ thị swap để tổ chức mutual exclusion b)Hãy chứng minh các tiến trình thỏa yêu cầu mutual exclusion c)Cho ví dụ với n tiến trình BÀI TẬP DEADLOCK 1)Cho trạng thái hiện hành của hệ thống như sau: MAX(tối đa) ALLOCATION(đang có) AVAILABLE(dự trữ) R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 3 2 2 1 0 0 4 1 2 P2 6 1 2 2 1 1 P3 3 1 4 2 1 1 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à vẫn bảo đảm không xảy ra tình trạng deadlock hay không? Giải Vì AVAILABLE[1]=4, AVAILABLE[3]=2 thỏa mãn yêu cầu P2, ta có : MAX ALLOCATION AVAILABLE R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 3 2 2 1 0 0 0 1 0 P2 6 1 3 6 1 3 P3 3 1 4 2 1 1 P4 4 2 2 0 0 2 MAX ALLOCATION AVAILABLE R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 3 2 2 1 2 0 6 2 3 P2 0 0 0 0 0 0 P3 3 1 4 2 1 1 P4 4 2 2 0 0 2 MAX ALLOCATION AVAILABLE R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 3 2 2 3 2 2 4 0 1 P2 0 0 0 0 0 0 P3 3 1 4 2 1 1 P4 4 2 2 0 0 2 MAX ALLOCATION AVAILABLE R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 0 0 0 0 0 0 6 2 3 P2 0 0 0 0 0 0 P3 3 1 4 2 1 1 P4 4 2 2 0 0 2 MAX ALLOCATION AVAILABLE R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 0 0 0 0 0 0 2 0 3 P2 0 0 0 0 0 0 P3 3 1 4 2 1 1 P4 0 0 0 0 0 0 MAX ALLOCATION AVAILABLE R1 R2 R3 R1 R2 R3 R1 R2 R3 P1 0 0 0 0 0 0 6 2 3 P2 0 0 0 0 0 0 P3 3 1 4 2 1 1 P4 0 0 0 0 0 0 SLEEPING BARBER PROBLEM Một tiệm cắt tóc có n ghế cho khách chờ, 1 ghế hớt tóc và 1 thợ hớt tóc.  Nếu khách hàng vào tiệm và không có ghế trống, thì khách đi về  Nếu khách vào tiệm nhưng thợ ngủ thì khách hàng đánh thức và hớt tóc  Ngược lại, khách ngồi chờ.  Nếu thợ cắt xong, thì hớt cho khách kế tiếp. Ngược lại thợ đi ngủ Hãy sử dụng semaphore, viết các hàm chức năng điều khiển hoạt động của thợ và khách. Giải Share semaphore cutHair=0; Share semaphore waiting=0; Share semaphore countMutex=1; Void barber() { While (true) { P(cutHair); GiveHaircut (); } } Void customer() { P(countMutex); If (count== n+1) Exit (); Count=count +1; If (count > 1) { // //take a chair // V( countMutex); P(waiting); } Else V(countMutex); // V(cutHair); ReceiveHair(); // [...]... nghĩa là tiến trình 1 muốn vào miền găng, khi ra khỏi sẽ gán thành false Giả sử P1 xử lý trước nên p1wantstoenter =true ->tiến trình 1 sẽ bỏ qua điều kiện vòng while do khi đó p2wantstoenter =false -> P1 vào miền găng Trong khi P1 ở trong miền găng thì tiến trình P2 muốn vào miền găng nhưng do điều kiện while p1wantstoenter =true nên P2 phải thực hiện vòng while này Biến favoredprocess=first làm cho P2... vào miền găng : wantIn[myPid] = true ; turn = otherPid  Khi đó điều kiện wantIn[otherPid] && turn == otherPid bằng false ->P1 vào miền găng Trong khi đó, nếu P2 muốn vào miền găng thì điều kiện while không thỏa, nghĩa là điề kiện bằng true ->làm cho P2 phải chờ cho đến khi P1 ra khỏi miền găng  Xét trường hợp cả hai tiến trình cùng thực hiện , cùng gán wantIn[myPid] = wantIn[otherPid] = true ; nhưng...P( countMutex); Count=count – 1; If ( count > 0 ) V( waiting); V(countMutex); } Bài tập Mutual Exclusion *Xét đoạn code sau : Share Boolean waiting[MAX_PID]=false; Share Boolean lock = false ; Int pid = ThisProcessPid(); Boolean ts; Int nextPid; // waiting[pid]=true; ts= true;... Nếu ts bằng false thì hàm TestAndSet phải trả về false đồng thời gán lock=true Bất kỳ tiến trình nào muốn vào miền găng thì hàm TestAndSet sẽ chặn lại Khi tiến trình ra khỏi miền găng thì biến lock gán bằng false Biến waiting[pid] cũng có thể gán false khi tiến trình nào đó rời khỏi miền găng Một tiến trình nào đó cũng có thể đặt phần tử biến waiting thành false nếu như nó không thể gán lock bằng true... tiến trình nào đó rời khỏi miền găng Một tiến trình nào đó cũng có thể đặt phần tử biến waiting thành false nếu như nó không thể gán lock bằng true Như vậy chỉ có chỉ có một tiến trình trong miền bởi vì thành phần waiting của nó là false  Không có tiến trình nào có thể có biến ts bằng false ở cùng thời điểm      Vậy : Tính loại trừ lẫn nhau (mutual exclusion) được chứng minh *Cho đoạn code sau :... găng nhưng do điều kiện while p1wantstoenter =true nên P2 phải thực hiện vòng while này Biến favoredprocess=first làm cho P2 phải chờ trong khi P1 đang ở trong miền găng Biến favoredprocess=first làm cho điều kiện vòng while đúng nên buộc P2 phải chờ Khi P1 ra khỏi miền găng, nó gán biến favoredprocess=second và p1wantstoenter=false Như vậy tiến trình P2 mới thoát ra khỏi vòng while để vào miền găng Vậy... ) DoNoThing(); // Critical-Section Turn = otherPid; a)Chứng minh đoạn code này không thỏa mãn cơ chế truy xuất miền găng b) Sửa đoạn code để thỏa mãn tính mutual-exclusion Giải a)  Khi một tiến trình thực hiện muốn vào miền găng thì bị chặn bởi vòng while do turn # myPid  Một tiến trình ở ngoài miền găng sẽ ngăn cản tiến trình khác vào miền găng b) share int turn = 0; // int mypid= . chờ(do hàm TestAndSet trả về true) VÍ DỤ: P1 P2 P3  Do lock=true nên P1 thực hiện vòng While để chờ vào miền găng  Lock=false  Thực hiện hàm TestAndSet trả về false, thoát khỏi while. các tiến trình thỏa yêu cầu mutual exclusion c)Cho ví dụ với n tiến trình BÀI TẬP DEADLOCK 1)Cho trạng thái hiện hành của hệ thống như sau: MAX(tối đa) ALLOCATION(đang có) AVAILABLE(dự trữ) R1 R2. trường hợp này cho thấy khi tiến trình nào đó muốn vào vùng tranh chấp thì nó thực hiện hàm TestAndSet : hàm trả về false làm cho tiến trình bỏ qua vòng While, đồng thời gán lock=true để khóa