Module 7: Process Synchronization
Download
Report
Transcript Module 7: Process Synchronization
การประสานเวลากระบวนการ
Process Synchronization
นงลักษณ์ พรมทอง
วิเชษฐ์ พลายมาศ
Objectives
ึ ษาแนวคิดพืน
เพือ
่ ศก
้ ฐานเกีย
่ วกับการประสาน
ี ย
เวลาของซพ
ี ู ปั ญหาและวิธก
ี ารแก ้ไขเกีย
่ วกับ
การประสานเวลา
เพือ
่ ให ้รู ้เกีย
่ วกับแนวคิดพืน
้ ฐานและความเป็ นมา
เกีย
่ วกับการประสานเวลากระบวนการ สว่ นวิกฤติ
ฮาร์ดแวร์ประสานเวลา เซมาฟอร์
เพือ
่ ให ้เข ้าใจถึงปั ญหาของการประสานเวลา และ
วิธก
ี ารแก ้ไขโดยใชตั้ วเฝ้ าสงั เกต และภาวะติด
ตาย
Agenda
Basic Concepts
Scheduling Criteria
Scheduling Algorithms
Multiple-Processor Scheduling
Real-Time Scheduling
Algorithm Evaluation
Agenda: Process Synchronization
Background
The Critical-Section Problem
Peterson’s Solution
Synchronization Hardware
Semaphores
Classic Problems of Synchronization
Monitors
Synchronization Examples
Atomic Transactions
Background
การออกแบบระบบปฏิบต
ั ก
ิ าร คือการเกีย
่ วข ้องกับกระจัด
การกระบวนการและเธรด ในสภาพแวดล ้อมต่อไปนี้
มัลติโปรแกรมมิง (Multiprogramming)
มัลติโพรเซสซงิ (Multiprocessing)
การประมวลผลแบบกระจาย (Distributed processing) หรือ
คลัสเตอร์ (cluster)
จาเป็ นต ้องออกแบบเรือ
่ ง
การจัดการภาวะพร ้อมกัน (concurrency)
การประสานเวลา (synchronization)
Background (2)
ภาวะพร ้อมกันมักเกิดขึน
้ ภายใต ้สภาพแวดล ้อมที่
แตกต่างกัน ดังนี้
ั หลายชุด
แอพพลิเคชน
ั
สภาพแวดล ้อมแบบมัลติโปรแกรมมิงยินยอมให ้แอพพลิเคชน
หลายตัวสามารถกระทาการในเวลาเดียวกันได ้
ั
โครงสร ้างของแอพพลิเคชน
ภายใต ้แนวคิดของการออกแบบมอดุลาร์และโปรแกรมแบบ
ั สามารถทางานได ้อย่างมี
โครงสร ้าง บางแอพพลิเคชน
ิ ธิภาพเมือ
้
ประสท
่ มีการเรียกใชกระบวนการร่
วมกัน
โครงสร ้างระบบปฏิบต
ั ก
ิ าร
ระบบปฏิบต
ั ก
ิ ารสมัยใหม่ได ้มีการออกแบบให ้กลุม
่ กระบวนการ
สามารถทางานไปพร ้อมๆ กันได ้
Background (3)
การเข ้าถึงข ้อมูลในเวลาพร ้อมๆ กันอาจเป็ นเหตุให ้เกิดความ
ขัดแย ้งกันของข ้อมูลได ้
ั กลไก
การดูแลให ้ข ้อมูลมีความสอดคล ้องกันย่อมต ้องอาศย
การจัดลาดับการประมวลผลเพือ
่ ทาหน ้าทีป
่ ระสานงานกับ
กระบวนการต่างๆ
ถ ้าเราใชวิ้ ธก
ี ารแก ้ปั ญหา consumer-producer problem
โดยใชบั้ ฟเฟอร์ทงั ้ หมด เราสามารถทาได ้โดยการใช ้
integer count เพือ
่ จัดเก็บจานวน track ทัง้ หมดของ
บัฟเฟอร์ทเี่ ต็ม
โดยกาหนดค่าเริม
่ ต ้นเป็ น 0 และจะเพิม
่ ค่าขึน
้ โดย
producer เมือ
่ มีบฟ
ั เฟอร์วา่ งใหม่เข ้ามา
้ ฟเฟอร์
และจะลดค่าลงโดย consumer หลังจากใชบั
Producer
while (true)
/* produce an item and put in nextProduced
while (count == BUFFER_SIZE)
; // do nothing
buffer [in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
count++;
}
Consumer
while (1)
{
while (count == 0)
; // do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
count--;
/* consume the item in nextConsumed
}
สภาวะการแย่งชงิ
(race condition)
ในสถานการณ์ทม
ี่ ห
ี ลายกระบวนการเข ้าถึงและ
เปลีย
่ นแปลงค่าข ้อมูลทีใ่ ชร่้ วมกันในเวลาพร ้อมกัน เรียกว่า
สภาวะการแย่งชงิ (race condition)
ผลลัพธ์ทไ
ี่ ด ้จะขึน
้ อยูก
่ บ
ั นโยบายการจัดลาดับ
(scheduling policy) ทีใ่ ช ้
การแก ้ปั ญหานีต
้ ้องประกันว่า จะมีเพียงกระบวนการเดียว
เท่านัน
้ ณ ขณะใดขณะหนึง่ ทีส
่ ามารถเปลีย
่ นแปลงค่าตัว
ั การประสานเวลา
แปร counter ได ้ ซงึ่ จาเป็ นต ้องอาศย
กระบวนการ (synchronized) เข ้ามาชว่ ย
Race Condition
count++ could be implemented as
register1 = count
register1 = register1 + 1
count = register1
count-- could be implemented as
register2 = count
register2 = register2 - 1
count = register2
Consider this execution interleaving with “count = 5” initially:
S0: producer execute register1 = count {register1 = 5}
S1: producer execute register1 = register1 + 1 {register1 = 6}
S2: consumer execute register2 = count {register2 = 5}
S3: consumer execute register2 = register2 - 1 {register2 = 4}
S4: producer execute count = register1 {count = 6 }
S5: consumer execute count = register2 {count = 4}
count อาจเป็ น 4 หรือ 6 ก็ได ้ แต่คา่ ทีถ
่ ก
ู ต ้องคือ 5
่ นวิกฤติ
สว
Critical Section
ถ ้าในระบบหนึง
่ ประกอบด ้วยกระบวนการหรือเธรดจานวน n {T0, T1, …,
Tn-1}
ในการควบคุมการเข ้าถึงทรัพยากรทีส
่ ามารถใชร่้ วมกันได ้โดยกระบวนการ
หรือเธรดทัง้ หมดนั น
้ สามารถทาได ้โดยกาหนดให ้แต่ละเธรดจะมีสว่ นของ
้
รหัสทีเ่ รียกว่า สว่ นวิกฤติ (critical section) ทีเ่ ธรดใชในการเปลี
ย
่ นค่าของ
ตัวแปรร่วม, การแก ้ไขตาราง, เขียนแฟ้ ม และอืน
่ ๆ
คุณลักษณะสาคัญของระบบนีก
้ ็คอ
ื เมือ
่ มีเธรดหนึง่ กาลังกระทาการอยูใ่ น
สว่ นวิกฤติ จะต ้องไม่มเี ธรดใดๆ ทีไ่ ด ้รับอนุญาตให ้เข ้าใชส้ ว่ นวิกฤตินไ
ี้ ด ้
่ นวิกฤติ
การแก้ปญ
ั หาสว
1. การไม่เกิดร่วม (mutual exclusion)
ถ ้ามีเธรด Ti กาลังเข ้ากระทาการบริเวณสว่ นวิกฤติอยู่ จะต ้องไม่มเี ธรดอืน
่
ใดสามารถเข ้าใชส้ ว่ นวิกฤตินไ
ี้ ด ้
2. ความก้าวหน้า (Progress)
ถ ้าไม่มเี ธรดใดเข ้ากระทาการอยูใ่ นสว่ นวิกฤติ และมีเธรดใดๆ รอเข ้าใชส้ ว่ น
วิกฤติ เธรดเหล่านั น
้ จะต ้องได ้รับอนุญาตให ้เข ้าใชส้ ว่ นวิกฤติได ้ทันทีโดย
ไม่ต ้องรอเวลาใดๆ
3. การรอทีม
่ ข
ี อบเขต (Bounded waiting)
เมือ
่ เธรดใดๆ ทาการร ้องขอสว่ นวิกฤติ การร ้องขอนั น
้ จะต ้องได ้รับการ
ตอบสนองอย่างรวดเร็วทีส
่ ด
ุ เท่าทีจ
่ ะเป็ นไปได ้นั บตัง้ แต่มก
ี ารร ้องขอ โดย
ิ้ สุด ทัง้ นี้ เพือ
ไม่เกิดภาวะรอคอยอย่างไม่มข
ี อบเขตสน
่ ป้ องกันภาวะงูกน
ิ
หาง (starvation)
Initial Attempts to Solve Problem
Only 2 processes, P0 and P1
General structure of process Pi (other process Pj)
do {
entry section
critical section
exit section
reminder section
} while (1);
กระบวนการทัง้ หมดสามารถใชตั้ วแปรร่วมกันในการประสานการ
ทางานกัน
้ สจ
อัลกอริธม
ึ ทีใ่ ชพิ
ู น์แบบจาลองนีม
้ ี 3 แบบ
Algorithm 1
Shared variables:
int turn;
initially turn = 0
turn - i Pi can enter its critical section
Process Pi
do {
while (turn != i) ;
critical section
turn = j;
reminder section
} while (1);
อ ัลกอริธม
ึ นีร้ องร ับการไม่เกิดร่วม (Mutual Exclusion) แต่ไม่
รองร ับความก้าวหน้า (Progress)
Algorithm 2
Shared variables
boolean flag[2];
initially flag [0] = flag [1] = false.
flag [i] = true Pi ready to enter its critical section
Process Pi
do {
flag[i] := true;
while (flag[j]) ;
critical section
flag [i] = false;
remainder section
} while (1);
อ ัลกอริธม
ึ นี้ รองร ับการไม่เกิดร่วม (Mutual Exclusion) แต่ไม่
รองร ับความก้าวหน้า (Progress)
Algorithm 3
Combined shared variables of algorithms 1 and 2.
Process Pi
do {
flag [i]:= true;
turn = j;
while (flag [j] and turn = j) ;
critical section
flag [i] = false;
remainder section
} while (1);
อัลกอริธม
ึ นี้ รองรับเงือ
่ นไขได ้ทัง้ 3 ข ้อ และสามารถแก ้ปั ญหาสว่ น
วิกฤติสาหรับ 2 กระบวนการได ้
ฮาร์ดแวร์ประสานเวลา
Synchronization Hardware
บนระบบโพรเซสเซอร์เดียวสามารถระงับการใช ้ interrupts
สามารถรับประกันได ้ว่าลาดับของชุดคาสงั่ จะถูกกระทาการโดย
ี ย
ปราศจาการบังคับให ้ออกจากเวลาซพ
ี ู
้
บนมัลติโพรเซสเซอร์ ไม่สามารถใชงานได
้
้
การห ้ามขัดจังหวะบนโปรเซสเซอร์หลายตัวนัน
้ ใชเวลานานมากใน
การสง่ ข่าวสารไปยังโปรเซสเซอร์ทก
ุ ตัว
การสง่ ข่าวสารจะก่อให ้เกิดการหน่วงเวลาไปยังสว่ นวิกฤติของทุก
ิ ธิภาพของระบบลดลง
โปรเซสเซอร์ซงึ่ สง่ ผลให ้ประสท
ิ
ิ
ยังสง่ ผลกระทบต่อนาฬกาของระบบอี
กด ้วยถ ้านาฬกาบั
นทึกเวลาที่
ถูกเปลีย
่ นค่าโดยการขัดจังหวะ
ฮาร์ดแวร์ประสานเวลา
Synchronization Hardware
เครือ
่ งในหลายระบบจึงจัดเตรียมชุดคาสงั่ ระดับฮาร์ดแวร์ท ี่
ใชส้ าหรับทดสอบและเปลีย
่ นค่าของคา หรือสาหรับสลับค่า
ระหว่างคา 2 คาแบบภาวะครบหน่วย (atomic instruction)
Atomic
= non-interruptable
ั่ ฮาร์ดแวร์ประสานเวลาทีจ
ชุดคาสง
่ ัดเตรียมไว ้เพือ
่ แก ้ปั ญหา
นีป
้ ระกอบด ้วย
Test-and-Set Instruction
Swap Instruction
Test-and-Set Instruction
Definition:
boolean TestAndSet (boolean *target)
{
boolean rv = *target;
*target = TRUE;
return rv:
}
Solution using TestAndSet
Shared boolean variable lock., initialized to false.
Solution:
do {
while ( TestAndSet (&lock ))
; /* do nothing
//
critical section
lock = FALSE;
//
remainder section
} while ( TRUE);
Swap Instruction
Definition:
void Swap (boolean *a, boolean *b)
{
boolean temp = *a;
*a = *b;
*b = temp:
}
Solution using Swap
Shared Boolean variable lock initialized to FALSE; Each
process has a local Boolean variable key.
Solution:
do {
key = TRUE;
while ( key == TRUE)
Swap (&lock, &key );
//
critical section
lock = FALSE;
//
remainder section
} while ( TRUE);
เซมาฟอร์
Semaphore
เป็ นเครือ
่ งมือประสานเวลาทีไ่ ม่ต ้องการเวลารอคอย
เซมาฟอร์ S เป็ นตัวแปรจานวนเต็ม (integer) ชว่ ยลดความ
ั ซอน
้ สามารถเข ้าถึงได ้ผ่านคาสงั่ ปฏิบต
ซบ
ั ก
ิ ารมาตรฐาน 2
คาสงั่ ปฏิบต
ั ก
ิ ารแบบภาวะครบหน่วย (atomic operation)
ได ้แก่
wait และ signal
ั่ ปฏิบต
คาสง
ั ก
ิ ารแบบภาวะครบหน่วย (atomic operation)
เมือ
่ กระบวนการหนึง่ กาลังแก ้ไขค่าเซมาฟอร์ จะต ้องไม่มก
ี ระบวนการ
อืน
่ ทีส
่ ามารถแก ้ไขค่าเซมาฟอร์เดียวกันได ้ในเวลาเดียวกัน
กรณีของ wait(S) การทดสอบค่าจานวนเต็มของ S (S 0) และการ
แก ้ไขค่า (S--) จะต ้องกระทาการโดยปราศจากขัดจังหวะ
เซมาฟอร์ (2)
Semaphore
S: wait() and signal()
Originally called P() and V()
wait (S) {
while S <= 0
; // no-op
S--;
}
signal (S) {
S++;
}
Semaphore as General Synchronization Tool
แบ่งตัวแปรเซมาฟอร์ออกเป็ น 2 ชนิด ได ้แก่
เซมาฟอร์นับ (Counting semaphore) มีคา่ ทีเ่ ป็ นไปได ้ไม่จากัด
เซมาฟอร์ไบนารี (Binary semaphore) มีคา่ ทีเ่ ป็ นได ้คือ 0 และ 1 ง่าย
้
ต่อการใชงาน
บางทีเรียกว่า mutex locks
่ นค่าทีเ่ ป็ นไปได ้ของเซมาฟอร์
โดยค่าของเซมาฟอร์นับไม่จากัดขอบเขต สว
้
ไบนารีได ้แก่ 0 กับ 1 เพือ
่ ให ้ใชงานได
้ง่าย
สามารถใช ้ counting semaphore S เป็ นไบนารีเซมาฟอร์
Provides mutual exclusion
Semaphore S;
wait (S);
// initialized to 1
Critical Section
signal (S);
Semaphore Implementation
้
เราสามารถใชเซมาฟอร์
ไบนารีควบคุมการเข ้าถึงสว่ นวิกฤติสาหรับ
กระบวนการหรือเธรดใดๆ โดยจะมีเพียงเธรดเดียวเท่านั น
้ ทีส
่ ามารถเข ้า
่ ว่ นวิกฤติได ้ ณ ขณะใดขณะหนึง่
สูส
่ นเซมาฟอร์นับสามารถใชควบคุ
้
สว
มการเข ้าถึงทรัพยากรทีส
่ อดคล ้อง
กันเพียงค่าจานวนจากัดเท่านั น
้
้
โดยเซมาฟอร์จะกาหนดค่าของจานวนทรัพยากรทีส
่ ามารถใชงานได
้
้ พยากรดังกล่าวก็จะเรียกคาสงั่ ปฏิบต
แต่ละเธรดทีต
่ ้องการใชทรั
ั ก
ิ าร P
บนเซมาฟอร์ (เพือ
่ ลดค่าจานวนนั บ)
เมือ
่ เธรดนั น
้ ปลดปล่อยทรัพยากรก็จะเรียกคาสงั่ ปฏิบัตก
ิ าร V (เพิม
่ ค่า
จานวนนั บ)
เมือ
่ ค่าจานวนนั บของเซมาฟอร์ไปจนถึงค่า 0 ก็แสดงว่าทรัพยากร
้
ทัง้ หมดกาลังถูกใชงาน
ในระหว่างนี้ ถ ้าเธรดใดร ้องขอทรัพยากรก็จะต ้องถูกหยุดให ้รอ
จนกระทั่งค่าตัวนั บมากกว่า 0
Semaphore Implementation with no Busy waiting
ื่ มโยงไปยังแถวคอย (waiting queue)
เซมาฟอร์แต่ละตัวจะมีการเชอ
แต่ละรายการในแถวคอยจะมีเพียง 2 รายการ
value (of type integer)
pointer (ตัวชไี้ ปยังเรคคอร์ดถัดไปในรายการ)
Two operations:
block –หยุดกระบวนการทีร่ ้องขอ
wakeup(P) กลับมากระทาการกระบวนการ P ทีถ
่ ก
ู หยุดไว ้ต่อ
(โดยเปลีย
่ นสถานะจากรอเป็ นพร ้อม)
Semaphore Implementation with no Busy waiting (Cont.)
Implementation of wait:
wait (S){
value--;
if (value < 0) {
add this process to waiting queue
block(); }
}
Implementation of signal:
Signal (S){
value++;
if (value <= 0) {
remove a process P from the waiting queue
wakeup(P); }
}
ภาวะติดตายและงูกน
ิ หาง
Deadlock and Starvation on Semaphore
้ ไปต่าง
ภาวะติดตาย (Deadlock) กระบวนการตงแต่
ั้
2 กระบวนการขึน
ฝ่ายต่างกาล ังรอคอยซงึ่ ก ันและก ันอย่างไม่รจ
ู ้ บ เพือ
่ ให ้เหตุการณ์
ั กระบวนการหนึง่
บางอย่างเกิดขึน
้ โดยทีเ่ หตุการณ์นัน
้ จะเกิดขึน
้ ได ้โดยอาศย
แต่กระบวนการก็กาลังรอคอยอะไรบางอย่างด ้วย
Let S and Q be two semaphores initialized to 1
P0
P1
wait (S);
wait (Q);
wait (Q);
wait (S);
.
.
.
.
.
.
signal (S);
signal (Q);
signal (Q);
signal (S);
ภาวะงูกน
ิ หาง (starvation) หรือ การหยุดรออย่างไม่มก
ี าหนด (indefinite
blocking) เป็ นสถานการณ์ทม
ี่ ห
ี ลายกระบวนการกาลังรอคอยอย่างไม่ม ี
้
กาหนดอยูภ
่ ายในเซมาฟอร์ เพราะมีกระบวนการหนึง่ กาลังใชเซมาฟอร์
อยู่
้ ฐานของการประสานเวลา
ปัญหาพืน
Classical Problems of Synchronization
้
ปั ญหาพืน
้ ฐานทีใ่ ชทดสอบวิ
ธก
ี ารแก ้ปั ญหาการประสาน
เวลา
Bounded-Buffer problem (Producer/Consumer
problem)
Readers and Writers problem
Dining-Philosophers problem
Bounded-Buffer Problem
บางทีเรียกว่าปั ญหาผู ้ผลิต-ผู ้บริโภค
(Producer/Consumer problem)
้
ิ ธิภาพของเทคนิค
เป็ นปั ญหาทีน
่ ย
ิ มใชในการทดสอบประส
ท
การประสานเวลา
มีผู ้ผลิตหนึง
่ คนหรือมากกว่าทาการผลิตข ้อมูลบางชนิด
่ งในบัฟเฟอร์ และมีผู ้บริโภค
(ระเบียน, อักขระ) และใสล
เพียงคนเดียวเท่านัน
้ ทีส
่ ามารถหยิบข ้อมูลนัน
้ ออกจาก
บัฟเฟอร์ในขณะใดขณะหนึง่
ระบบจะต ้องกาหนดเงือ
่ นไขเพือ
่ ป้ องกันไม่ให ้เกิดการทับ
้
ซอนกั
นในการปฏิบต
ั ก
ิ ารบนบัฟเฟอร์นัน
้ หมายความว่า ณ
ขณะใดขณะหนึง่ จะมี (ผู ้ผลิตหรือผู ้บริโภค) เพียงคนเดียว
เท่านัน
้ ทีส
่ ามารถเข ้าถึงบัฟเฟอร์ได ้
Bounded-Buffer Problem (Cont.)
N buffers, each can hold one item
Semaphore mutex initialized to the value 1
Semaphore full initialized to the value 0
Semaphore empty initialized to the value N.
Bounded Buffer Problem (Cont.)
The structure of the producer process
do {
// produce an item
wait (empty);
wait (mutex);
// add the item to the buffer
signal (mutex);
signal (full);
} while (true);
Bounded Buffer Problem (Cont.)
The structure of the consumer process
do {
wait (full);
wait (mutex);
// remove an item from buffer
signal (mutex);
signal (empty);
// consume the removed item
} while (true);
Readers-Writers Problem
้
ปั ญหาผู ้อ่าน-ผู ้เขียนถือเป็ นปั ญหาทีใ่ ชในการทดสอบกลไกการ
แก ้ปั ญหาเกีย
่ วกับการควบคุมภาวะพร ้อมกัน
ชุดข ้อมูลทีใ่ ชร่้ วมกันระหว่างกระบวนการทัง้ หมดในเวลาเดียวกัน
นัน
้
ผู ้อ่าน สามารถอ่านข ้อมูลได ้อย่างเดียว, ไม่มก
ี าร update
ผู ้เขียน สามารถทาได ้ทัง้ อ่านและเขียน
ปั ญหานีค
้ อ
ื มีพน
ื้ ทีข
่ ้อมูลซงึ่ ใชร่้ วมกันได ้ระหว่างกระบวนการ
ทัง้ หมด มีกระบวนการจานวนมากทีต
่ ้องการอ่าน (readers) พืน
้ ที่
ดังกล่าวเพียงอย่างเดียว และมีกระบวนการทีต
่ ้องการเขียน
(writers) บนพืน
้ ทีด
่ งั กล่าวเพียงกระบวนการเดียวในเวลาเดียวกัน
Readers-Writers Problem (Cont.)
การจัดการจะต ้องเข ้ากันได ้กับเงือ
่ นไขดังต่อไปนี้
1. ผู ้อ่านสามารถอ่านแฟ้ มได ้พร ้อมกันหลายคน
2. มีผู ้เขียนเพียงคนเดียวเท่านั น
้ ทีส
่ ามารถเขียนแฟ้ มได ้ ณ เวลาใดเวลา
หนึง่
3. ถ ้ามีผู ้เขียนรอทีจ
่ ะเขียนแฟ้ ม จะต ้องไม่มผ
ี ู ้อ่านคนใดสามารถอ่าน
แฟ้ มนั น
้ ได ้
่ ั ญหาภาวะงูกน
จากข ้อกาหนดข ้างต ้นอาจนาไปสูป
ิ หาง
กรณีแรก ผู ้เขียนอาจต ้องเป็ นฝ่ ายรออย่างไม่รู ้จบ
กรณีหลัง ผู ้อ่านอาจต ้องเป็ นฝ่ ายรออย่างไม่รู ้จบ
Shared Data
Data set
Semaphore mutex initialized to 1.
Semaphore wrt initialized to 1.
Integer readcount initialized to 0.
Readers-Writers Problem (Cont.)
The structure of a writer process
do {
wait (wrt) ;
//
writing is performed
signal (wrt) ;
} while (true)
Readers-Writers Problem (Cont.)
The structure of a reader process
do {
wait (mutex) ;
readcount ++ ;
if (readercount == 1) wait (wrt) ;
signal (mutex)
// reading is performed
wait (mutex) ;
readcount - - ;
if redacount == 0) signal (wrt) ;
signal (mutex) ;
} while (true)
Dining-Philosophers Problem
Shared data
Bowl of rice (data set)
Semaphore chopstick [5] initialized to 1
Dining-Philosophers Problem (Cont.)
นักปรัชญาจานวน 5 คนนั่งบนเก ้าอีล
้ ้อมรอบโต๊ะกลม
่ ้าวจานวน 5 ถ ้วยวางไว ้บนโต๊ะ
มีถ ้วยใสข
้ อและด ้านขวามือของเขา
มีตะเกียบอยูจ
่ านวน 5 อันวางไว ้ด ้านซายมื
ข ้างละหนึง่ อัน
้
เมือ
่ เวลาหิวก็จะพยายามหยิบตะเกียบจากด ้านซายและขวามื
อขึน
้ มา
ข ้างละอันจึงจะสามารถบริโภคอาหารได ้ และในระหว่างบริโภคก็จะ
ไม่วางตะเกียบตลอดจนกระทั่งอิม
่ จึงค่อยวางตะเกียบลง
ถ ้ามีนักปรัชญาทีน
่ ั่งอยูด
่ ้านข ้างหิวและพยายามหยิบตะเกียบขึน
้ มา
แต่ถ ้าตะเกียบข ้างใดข ้างหนึง่ หรือทัง้ สองข ้างไม่วา่ งก็จะต ้องรอ
Dining-Philosophers Problem (Cont.)
The structure of Philosopher i:
Do {
wait ( chopstick[i] );
wait ( chopStick[ (i + 1) % 5] );
// eat
signal ( chopstick[i] );
signal (chopstick[ (i + 1) % 5] );
// think
} while (true) ;
Problems with Semaphores
สะท ้อนถึงปั ญหาสาคัญเกีย
่ วกับการควบคุมภาวะพร ้อมกันบน
่ การจัดสรรทรัพยากร
สภาพแวดล ้อมของระบบปฏิบต
ั ก
ิ าร เชน
จานวนมากให ้แก่กระบวนการจานวนมากทีอ
่ าจตกอยูภ
่ ายใต ้
สถานการณ์ของภาวะติดตายและงูกน
ิ หางทีม
่ ก
ี ารรออย่างไม่รู ้จบ
การแก ้ปั ญหาอย่างง่ายวิธห
ี นึง่ คือ
การแทนตะเกียบแต่ละอันด ้วยเซมาฟอร์
นักปรัชญาคนหนึง่ พยายามหยิบตะเกียบโดยการใชค้ าสงั่
ปฏิบต
ั ก
ิ าร P บนเซมาฟอร์
และวางตะเกียบโดยการใชค้ าสงั่ ปฏิบต
ั ก
ิ าร V บนเซมาฟอร์
ทีเ่ หมาะสม
Problems with Semaphores (Cont.)
Correct use of semaphore operations:
signal (mutex) …. wait (mutex)
wait (mutex) … wait (mutex)
Omitting of wait (mutex) or signal (mutex) (or both)
Problems with Semaphores (Cont.)
ในการป้ องกันภาวะติดตายจากสถานการณ์นี้ สามารถกาหนด
เงือ
่ นไข ดังต่อไปนี้
อนุญาตให ้นักปรัชญาเพียง 4 คนนั่งพร ้อมๆ กันอยูท
่ โี่ ต๊ะกลมได ้
้
อนุญาตให ้นักปรัชญาหยิบตะเกียบได ้ก็ตอ
่ เมือ
่ ตะเกียบด ้านซาย
และขวาวางไว ้อยู่ (เขาจะต ้องหยิบตะเกียบทัง้ คูใ่ นสว่ นวิกฤติ)
่ นักปรัชญาเลขคีจ
ใชวิ้ ธแ
ี ก ้ปั ญหาแบบอสมมาตร ตัวอย่างเชน
่ ะ
้ อน ถ ้าได ้จึงหยิบด ้านขวา ในขณะทีน
หยิบตะเกียบด ้านซายก่
่ ัก
ปรัชญาเลขคูใ่ ห ้เริม
่ หยิบตะเกียบด ้านขวาก่อนแลเวจึงหยิบ
้
ตะเกียบด ้านซาย
วิธก
ี ารนีจ
้ ะรับประกันว่าไม่มก
ี ารแย่งชงิ ทีเ่ ป็ นสาเหตุให ้นักปรัชญาคน
่ าวะติดตาย แต่วธิ น
หนึง่ เข ้าสูภ
ี ไี้ ม่ได ้ป้ องกันภาวะการรออย่างไม่รู ้จบ
ั
ต ัวเฝ้าสงเกต
Monitors
ั เกตเป็ นซอฟต์แวร์มอดูลทีป
ตัวเฝ้ าสง
่ ระกอบด ้วยหนึง่ หรือมากกว่ากระบวนงาน
(procedure) ทาการกาหนดค่าการจัดลาดับ และตัวแปรข ้อมูลเฉพาะที่
้
ิ ธิภาพทีใ่ ชส้ าหรับประสานเวลา
เป็ นกลไกทีใ่ ชงานง่
ายกว่าเซมาฟอร์ และมีประสท
กระบวนการ
ั เกตประกอบด ้วย
คุณลักษณะสาคัญของตัวเฝ้ าสง
ตัวแปรข ้อมูลเฉพาะทีจ
่ ะสามารถเข ้าถึงได ้โดยกระบวนงานเฉพาะทีข
่ องตัวเฝ้ า
สงั เกตเท่านั น
้ และไม่สามารถเข ้าถึงได ้โดยกระบวนงานอืน
่ ๆ จากภายนอก
่ วั เฝ้ าสงั เกตได ้โดยการเรียกกระบวนงานเฉพาะทีบ
กระบวนการเข ้าสูต
่ างอย่าง
ของตัวเฝ้ าสงั เกต
มีเพียงกระบวนการเดียวเท่านั น
้ ทีถ
่ ก
ู กระทาการได ้โดยตัวเฝ้ าสงั เกตในขณะใด
ขณะหนึง่ ถ ้ามีกระบวนการอืน
่ ต ้องการใชตั้ วเฝ้ าสงั เกตก็จะต ้องหยุดรอ
จนกระทั่งตัวเฝ้ าสงั เกตว่างลง
ณ เวลาใดเวลาหนึง
่ จะมีเพียงกระบวนการเดียวเท่านั น
้ ที่ active อยูภ
่ ายในตัวเฝ้ า
สงั เกต
ั
ต ัวเฝ้าสงเกต
Monitors
monitor monitor-name
{
// shared variable declarations
procedure P1 (…) { …. }
…
procedure Pn (…) {……}
Initialization code ( ….) { … }
…
}
}
Schematic view of a Monitor
Condition Variables
condition x, y;
Two operations on a condition variable:
x.wait () – a process that invokes the operation is
suspended.
x.signal () – resumes one of processes (if any) tha
invoked x.wait ()
Monitor with Condition Variables
Solution to Dining Philosophers
สาหรับการแก ้ปั ญหานักปรัชญาบริโภคนัน
้ กาหนดให ้
การจ่ายตะเกียบถูกควบคุมโดยตัวเฝ้ าสงั เกต
กาหนดให ้นักปรัชญาแต่ละคนก่อนจะเริม
่ ต ้นบริโภค
จะต ้องเรียกคาสงั่ pickUp() จนกระทัง่ สาเร็จจึงจะ
เริม
่ บริโภคได ้
ั่ putDown()
หลังจากบริโภคเสร็จต ้องเรียกคาสง
และเริม
่ คิดต่อไป
ดังนัน
้ นักปรัชญา i จะต ้องเรียกใชค้ าสงั่ pickUp() และ
putDown() ตามลาดับ
Solution to Dining Philosophers (cont.)
monitor DP
{
enum { THINKING; HUNGRY, EATING) state [5] ;
condition self [5];
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);
}
Solution to Dining Philosophers (cont.)
void test (int i) {
if ( (state[(i + 4) % 5] != EATING) &&
(state[i] == HUNGRY) &&
(state[(i + 1) % 5] != EATING) ) {
state[i] = EATING ;
self[i].signal () ;
}
}
initialization_code() {
for (int i = 0; i < 5; i++)
state[i] = THINKING;
}
}
Synchronization Examples
Solaris
Windows XP
Linux
Pthreads
Solaris Synchronization
การใช ้ lock หลายแบบ เพือ
่ สนับสนุนระบบ multitasking และ
multithreading (รวมทัง้ real-time threads) และ
multiprocessing
ใช ้ adaptive mutexes เพือ
่ ความสะดวกในการป้ องกันข ้อมูลจาก
้
ั ้ ๆ short code segments
รหัสเซกเมนท์
สน
็
ใช ้ lock แบบ condition variables and readers-writers เมือ
่ เซก
ั ของรหัสทีย
ชน
่ าวกว่าต ้องการใชข้ ้อมูล
ใช ้ turnstiles ในการจัดลาดับรายการเธรดทีก
่ าลังรอคอย ทีต
่ ้องการ
adaptive mutex or reader-writer lock
Windows XP Synchronization
ใช ้ interrupt เพือ
่ ป้ องกันการเข ้าถึงทรัพยากรสว่ นกลางบนระบบ
โพรเซสเซอร์เดียว (uniprocessor systems)
ใช ้ spinlocks บน multiprocessor systems
มีการเตรียม dispatcher objects ทีท
่ าหน ้าทีเ่ ป็ น mutexes และ
semaphores
Dispatcher objects อาจจัดหาเหตุการณ์บางอย่าง (events)
่ เดียวกันตัวแปรแบบมีเงือ
เหตุการณ์ทาหน ้าทีเ่ ชน
่ นไข
(condition variable)
Linux Synchronization
Linux:
ระงับการใช ้ interrupts โดยใชส้ ว่ นวิกฤติขนาดเล็ก (short
critical sections) แทน
Linux provides:
semaphores
spin locks
Pthreads Synchronization
Pthreads API is OS-independent
It provides:
mutex locks
condition variables
Non-portable extensions include:
read-write locks
spin locks
End of Process Synchronization