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