Os ch02

ระบบปฏิบัติการ (Operating Systems) 1
บทที่ 2
โปรเซส และ
Thread

ความหมายของโปรเซสความหมายของโปรเซส
 โปรแกรมที่กำาลังถูกเอ็กซิคิวต์
 โปรแกรมที่กำาลังทำางานอยู่
 กิจกรรมที่มีการทำางานสัมพันธ์กัน
 สิ่งที่กำาลังใช้งานโปรเซสเซอร์อยู่

Process ในระบบปฏิบัติการ
Windows

Process ในระบบปฏิบัติการ Linux

1. องค์ประกอบของโปรเซส1. องค์ประกอบของโปรเซส
 หมายเลขโปรเซส (Process ID) เป็นหมายเลข
ประจำาโปรเซสเพื่อกำาหนดลำาดับ
 โค้ดโปรแกรม (Program Code) ภาษาเครื่องใช้
สำาหรับเอ็กซิคิวต์
 ข้อมูล (Data) เป็นตัวแปรโกลบอล
 บล็อกควบคุมโปรเซส (Process Control Block
) หรือ PCB
 PSW (Program Status Word) ตัวควบคุมลำาดับ
การเอ็กซิคิวต์คำาสั่งของโปรเซส และเก็บข้อมูลสถานะ
ของโปรเซส
 คุณสมบัติของโปรเซส


บล็อกควบคุมโปรเซส (PCB)บล็อกควบคุมโปรเซส (PCB)
 พอยเตอร์ (Pointer) ใช้ชี้ตำาแหน่งของโปรเซสใน
หน่วยความจำา
 สถานะของโปรเซส (Process state) ใช้แสดง
สถานะของโปรเซสในปัจจุบัน
 หมายเลขของโปรเซส (Process ID) เป็น
หมายเลขประจำาตัวของโปรเซส
 ตัวนับจำานวน (Program counter) เป็นตัวนับ
แสดงที่อยู่ของคำาสั่งต่อไป
 รีจิสเตอร์ (Register) เก็บข้อมูลสถานะระบบเมื่อมี
interrupt เกิดขึ้น
 ข้อมูลการจัดการเวลาของซีพียู (CPU
scheduling information)
 ข้อมูลการจัดการหน่วยความจำา (Memory

บล็อกควบคุมโปรเซส
(PCB)

2. สถานะของโปรเซส2. สถานะของโปรเซส
 สถานะเริ่มต้น (New)
 สถานะพร้อม (Ready)
 สถานะรัน (Run)
 สถานะรอ,พัก (Wait)
 สถานะบล็อก (Block)
 สถานะสิ้นสุด (Terminate)

ไดอะแกรมของสถานะ
โปรเซส

3. การจัดเวลาโปรเซส3. การจัดเวลาโปรเซส
 ใช้ในระบบมัลติโปรแกรมมิ่ง คือการจัดโปรเซส
ให้รันตลอดเวลา เพื่อให้ใช้ประโยชน์ซีพียูได้
สูงสุด
 โปรเซสที่ระบบปฏิบัติการสร้างขึ้นมาใหม่จะอยู่
ในสถานะพร้อมและเก็บ อยู่ในคิว เรียกว่า
Ready Queue เพื่อรอการรัน
 ต้องพิจารณาหน่วยความจำาของระบบมีเพียงพอ
หรือไม่
 Ready Queue จะเก็บโปรเซสในลักษณะลิงค์
ลิสต์ (Link list) ที่ส่วนหัวของคิว จะประกอบ

คิวที่พร้อมทำางานและ
อินพุต/เอาต์พุตอื่น ๆ
หัว
ท้า
ย

3. การจัดเวลาโปรเซส3. การจัดเวลาโปรเซส
ปัญหา : หากมีโปรเซสใดต้องใช้เวลานาน ๆ จะ
ทำาให้โปรเซสอื่นที่อยู่ในคิวต้องเสียเวลารอนาน
เกินไป
วิธีแก้ไข : กำาหนดเวลาในการอยู่ในสถานะรัน
ของโปรเซสทุกโปรเซส เรียกว่าเวลาควันตัม
(Quantum time) ถ้าเกินจะไปต่อคิวใหม่

การบล็อกโปรเซสเมื่อต้องการใช้ I/O หรือมี
การอินเทอร์รัพต์
โปรเซสที่ใช้เวลาเกินเวลาควันตัมจะย้ายไป
ต่อคิวใหม่

3.1) ดีไวซ์คิว (Device
Queue)
3.1) ดีไวซ์คิว (Device
Queue)
คิวของโปรเซสที่รอการตอบสนองจากการ
ใช้อินพุต/เอาต์พุตดีไวซ์

3.2) คอนเท็กซ์สวิตช์
(Context Switch)
3.2) คอนเท็กซ์สวิตช์
(Context Switch)
 เป็นการสวิตช์ไปยังโปรเซสในคิวต่อไป
เมื่อซีพียูทำางานโปรเซสนั้นเสร็จเรียบร้อย
แล้ว
 ระหว่างการสวิตช์จะไม่มีการทำางาน
 เวลาที่ใช้ขึ้นกับความเร็วของหน่วยความ
จำา, จำานวนรีจิสเตอร์ และคำาสั่งพิเศษใน
ระบบ
 คอนเท็กซ์สวิตช์กลายเป็นการเพิ่ม
ประสิทธิภาพในชื่อ Thread

ดงกระบวนการเปลี่ยนการประมวลผล (Context Switchin

4. โอเปอเรชันของโปรเซส4. โอเปอเรชันของโปรเซส
 การสร้างโปรเซส
 การสร้างโปรเซสจะกระทำาผ่าน System
Call “ ”โปรเซสที่สร้างเรียกว่า โปรเซสแม่
(Parent Process)
 ถ้าเป็นการสร้างในขณะเอ็กซิคิวต์โปรเซส
“ ”จะเรียกว่า โปรเซสลูก (Children
Process)
 โปรเซสลูกอาจจะใช้รีซอร์สจากระบบปฏิบัติ
การหรือผ่านทาง โปรเซสแม่ก็ได้
 โปรเซสแม่อาจจะแบ่งรีซอร์สเป็นส่วนย่อย ๆ

 การเอ็กซิคิวต์ (พร้อมกัน หรือรอให้โปรเซสลูก
เสร็จก่อนแม่จึงเอ็กซิคิวต์)
 แอ็ดเดรส (โปรเซสลูกสำาเนาจากโปรเซสแม่ หรือ
โหลดแอ็ดเดรสให้ตัวเอง)

PID หมายเลข Process (Process ID)
PPID หมายเลขของ Process ที่เป็นผู้
สร้าง (Parent PID)
PRI ค่า Prority
STAT แสดงสถานะของ Process
(Status)
- D รอการทำางานของ I/O
(uninterruptible sleep)
- R อยู่ระหว่างการประมวลผลใน

 การสิ้นสุดของโปรเซส
 โปรเซสลูกใช้รีซอร์สมากเกินที่กำาหนด
ไว้
 ไม่มีความจำาเป็นต้องใช้โปรเซสลูกนั้
นอีกแล้ว
 โปรเซสแม่สิ้นสุดไปแล้ว ระบบปฏิบัติ
การจะไม่ยินยอมให้เอ็กซิคิวต์โปรเซ
สลูก ( “สิ่งที่เกิดขึ้นเรียกว่า การสิ้นสุด
”เป็นขั้น ๆ (Cascading

5. โปรเซสสื่อประสาน
(Cooperating Process)
 โปรเซสจะเป็นโปรเซสสื่อประสานถ้า
โปรเซสนั้นมีผลกระทบหรือได้รับผลก
ระทบจากโปรเซสอื่นที่เอ็กซิคิวต์อยู่ใน
ระบบนั้น
 อาจกล่าวได้ว่าโปรเซสสื่อประสานจะมี
การแชร์ข้อมูลกับโปรเซสอื่นในระบบ
โดยระบบปฏิบัติการจะต้องแชร์หน่วย
ความจำาไว้ใช้งาน เนื้อที่หน่วยความ

 เหตุที่ทำาให้เกิดการประสานระหว่างโปรเซส
 การแชร์ข้อมูลข่าวสาร : ผู้ใช้หลายคน
ต้องการข้อมูลเดียวกัน ในเวลานั้น
 การเพิ่มความเร็วในการคำานวณ : โดย
การแบ่งโปรแกรมออกเป็นส่วนย่อย ๆ แล้ว
เอ็กซิคิวต์ขนานกันไป
 ความสะดวก : ผู้ใช้ต้องการทำางานหลาย
อย่างในเวลาเดียวกัน
 กลไกที่สนับสนุนให้โปรเซสสามารถประสาน
กันได้ คือ การติดต่อระหว่างโปรเซส

6. การติดต่อระหว่างโปรเซส
(IPC)
6. การติดต่อระหว่างโปรเซส
(IPC)
 โครงสร้างพื้นฐาน
 วิธีการติดต่อ
 การจัดบัฟเฟอร์
 เงื่อนไขยกเว้น

6.1) โครงสร้างพื้นฐาน6.1) โครงสร้างพื้นฐาน
 IPC สนับสนุนกลไกเพื่อให้โปรเซสสามารถ
ติดต่อซึ่งกันและกันได้อย่างมีประสิทธิภาพ ได้แก่
ระบบแมสเสจ (Message system)
 ฟังก์ชันของระบบแมสเสจที่ IPC สนับสนุนมี
อย่างน้อย 2 ประการคือ การส่งข้อมูล (Send
message) และรับข้อมูล (Receive message)
 เมื่อโปรเซสใดต้องการข้อมูลจากโปรเซสอื่นจะ
ส่งคำาร้องขอไปยังโปรเซสนั้น โปรเซสที่ถูก
ร้องขอจะส่งข้อมูลนั้นไปให้
 ขนาดของข้อมูลอาจจะมีขนาดคงที่ หรือขนาด
ไม่คงที่ก็ได้

คุณสมบัติของลิงค์ทางลอจิกคุณสมบัติของลิงค์ทางลอจิก
 จะสร้างลิงค์อย่างไร
 ลิงค์ที่สร้างนั้นสัมพันธ์กับโปรเซสมากก
ว่า 2 โปรเซสหรือไม่
 ระหว่างโปรเซสทั้งสองจะมีกี่ลิงค์
 ความจุของลิงค์เป็นเท่าไร
 ลิงค์นั้นมีบัพเฟอร์หรือไม่ ถ้ามีขนาดบัพ
เฟอร์เป็นเท่าไร
 ลิงค์เป็นแบบทางเดียว(undirectional)
หรือสองทิศทาง(bidirectional)

ลิงค์แบบลอจิกและโอเปอเรชันใน
การรับ-ส่งแมเสจ
ลิงค์แบบลอจิกและโอเปอเรชันใน
การรับ-ส่งแมเสจ
 การติดต่อเป็นแบบทางตรงหรือทางอ้อม
 การติดต่อเป็นแบบสมมาตร หรือไม่
สมมาตร
 การติดต่อเป็นแบบอัตโนมัติ หรือใช้
บัฟเฟอร์เฉพาะแบบ
 การส่งแมสเสจเป็นการส่งแบบสำาเนา
หรืออ้างอิง
 แมสเสจมีขนาดคงที่ หรือไม่คงที่

6.2) วิธีการติดต่อระหว่าง
โปรเซส
โปรเซส
 การติดต่อทางตรง (Direct
Communication) แต่ละโปรเซสที่
ต้องการติดต่อกันจะต้องกำาหนดชื่อ
เฉพาะที่ใช้ในการติดต่อทั้งโปรเซสที่
ต้องการรับ และโปรเซสที่ต้องการส่ง
Send (B,message) จะเป็นการส่งแมส
เสจไปยังโปรเซส B
Receive (A,message) จะเป็นการรับ
แมสเสจจากโปรเซส A

คุณสมบัติของลิงค์ของวิธีการ
ติดต่อทางตรง
ติดต่อทางตรง
 การสร้างลิงค์จะเป็นแบบอัตโนมัติ
ระหว่างคู่ของโปรเซสที่ต้องการติดต่อ
โปรเซสจะทราบหมายเลขของโปรเซส
ที่จะติดต่อด้วย
 ลิงค์หนึ่ง ๆ จะมีความสัมพันธ์เฉพาะ
โปรเซสสองโปรเซสเท่านั้น
 ระหว่างโปรเซสแต่ละคู่นั้นจะมีเพียง
ลิงค์เดียวเท่านั้น
 ลิงค์นี้เป็นได้ทั้งทิศทางเดียว และสอง

โปรเซส
โปรเซส
 การติดต่อทางอ้อม (Indirect
Communication) แต่ละโปรเซสที่
ต้องการติดต่อจะต้องติดต่อกันผ่านเมล
ล์บ็อกซ์(Mailbox) หรืออาจเรียกว่า
เป็นการติดต่อผ่านพอร์ต (Port) แต่ละ
เมลล์บ็อกซ์จะมีหมายเลขไม่ซำ้ากับเมล
ล์บ็อกซ์อื่น
Send(B,message) เป็นการส่งแมสเสจ

ติดต่อทางอ้อม
ติดต่อทางอ้อม
 จะมีการสร้างลิงค์ระหว่างโปรเซสที่มี
การแชร์เมลล์บ็อกซ์เท่านั้น
 ลิงค์หนึ่งๆ อาจจะมีความสัมพันธ์
มากกว่าสองโปรเซสได้
 ระหว่างโปรเซสแต่ละคู่นั้นอาจจะมี
หลายลิงค์ต่างกันได้ แต่ละลิงค์จะมี
เพียงเมลล์บ็อกซ์เดียว
 การลิงค์อาจจะเป็นทิศทางเดียว หรือ
สองทิศทางก็ได้

กลไกที่ระบบปฏิบัติการยอมให้โปรเซส
จัดการกับเมลล์บ็อกซ์
กลไกที่ระบบปฏิบัติการยอมให้โปรเซส
จัดการกับเมลล์บ็อกซ์
 สร้างเมลล์บ็อกซ์ใหม่
 ส่งและรับแมสเสจผ่านเมลล์บ็อกซ์
 ทำาลายเมลล์บ็อกซ์

รูปแบบของเมลล์บ็อกซ์รูปแบบของเมลล์บ็อกซ์
 เมลล์บ็อกซ์แบบคิว
ข้อมูล
เข้าเมล
ล์บ็อกซ์
ข้อมูล
ออก
เมลล์บ็
อกซ์FIFO (First In First
Out)

 เมลล์บ็อกซ์แบบไปป์
ข้อมูล
ข้อมูล
ออก
อกซ์FIFO (First In First
Out)

 เมลล์บ็อกซ์แบบสแต็ก
ข้อมูล
ข้อมูล
ออก
อกซ์
FILO (First In Last
Out)

6.3 การจัดบัฟเฟอร์ (Buffer)6.3 การจัดบัฟเฟอร์ (Buffer)
บัฟเฟอร์ คือคิวของแมสเสจที่ผูกติดกับ
ลิงค์ โดยพื้นฐานจะมีความจุ 3 ลักษณะ
 ความจุศูนย์ (Zero Capacity) : ใน
ลิงค์จะไม่มีแมสเสจรอ อยู่เลย
 ความจุแบบมีขอบเขต (Bounded
capacity) : จำานวนของแมสเสจในลิงค์
จะมีได้ไม่เกินจำานวนที่กำาหนด
 ความจุไม่มีขอบเขต (Unbounded
capacity) : จำานวนของแมสเสจในลิงค์

การ Asynchronous ระหว่าง
โปรเซส P และโปรเซส Q
การ Asynchronous ระหว่าง
โปรเซส P และโปรเซส Q
Process P…
send(Q,message);
receive(Q,message);
Process Q…
receive(P,message);
send(P,”Acknowledgment”)

6.4 เงื่อนไขยกเว้นในการติดต่อ
ระหว่างโปรเซส
 การสิ้นสุดของโปรเซส
ถ้าผู้รับหรือผู้ส่งแมสเสจสิ้นสุดก่อน
แมสเสจจะเอ็กซิคิวต์ ทำาให้แมสเสจถูก
กำาจัดทำาให้ผู้รับไม่ได้รับแมสเสจ หรือ
ผู้ส่งไม่ได้ส่งแมสเสจ

 การสูญหายของแมสเสจ
แมสเสจจากโปรเซส P ที่ส่งไปยัง
โปรเซส Q อาจจะสูญหายระหว่างทางของ
การสื่อสารก็ได้ ซึ่งอาจจะเป็นข้อผิดพลาด
ด้านฮาร์ดแวร์หรือสายสื่อสาร มี 3 วิธีพื้น
ฐานในการจัดการ
 OS มีหน้าที่รับผิดชอบในการตรวจสอบการ
สูญหายนี้เพื่อส่งแมสเสจใหม่
 โปรเซสที่ทำาหน้าที่ส่งแมสเสจมีหน้าที่รับผิดชอบ
ในการตรวจสอบการสูญหายเพื่อส่งแมสเสจใหม่

7. การซินโครไนซ์โปรเซส
(Process Synchronization)
7. การซินโครไนซ์โปรเซส
(Process Synchronization)
 โปรเซสที่มีความเป็นอิสระกันเรียกว่า
Asynchronous
 โปรเซสที่มีความเกี่ยวข้องกันเรียกว่า
Synchronous
 การซินโครไนซ์โปรเซสหรือการเข้า
จังหวะของโปรเซส หมายถึงการ
ทำางานของโปรเซส 2 โปรเซสที่มีความ
เกี่ยวข้องกัน เนื่องจาก

A B
C
D

X-->X+10
10
20
10
X-->X-10
A
B
X=10
X=20
X=20
X=10
โปรเซส A ทำางานก่อน
โปรเซส B
X-->X-10
10
0
10
X-->X+10
B
A
X=10
X=0
X=0
X=10
โปรเซส B ทำางานก่อน
โปรเซส A

X-->X+10
20 หรือ 0
10
X-->X-10A B
X=10
X=0
X=20
X=10
โปรเซส A และโปรเซส B ทำางานพร้อมกัน

8. โครงสร้างพื้นฐานการซิน
โครไนซ์
 Race Condition : สภาวะที่เกิดข้อผิด
พลาดเนื่องจากโปรเซสทำางานร่วมกันซึ่งมี
การใชัรีซอร์สร่วมกัน
 Mutual Exclusion : เป็นการกีดกันไม่
ให้โปรเซสอื่นเข้ามาใช้ รีซอร์สในขณะที่
มีโปรเซสอื่นครอบครองรีซอร์สนั้นอยู่
บริเวณหรือส่วนของโปรแกรมที่โปรเซส
ครอบครองรีซอร์สนั้นอยู่ เรียกว่า Critical
Region หรือ Critical Section


 คุณสมบัติของ Mutual Exclusion
 ต้องไม่มีโปรเซส 2 โปรเซสอยู่ใน
Critical Region พร้อมกัน
 ต้องไม่มีสมมุติฐานและข้อจำากัดเกี่ยวกับ
ความเร็ว และจำานวนซีพียูมาเกี่ยวข้อง
 ต้องไม่มีโปรเซสใด ๆ ภายนอก Critical
Region ที่บล็อกการทำางานของโปรเซ
สอื่น
 ต้องไม่มีโปรเซสใดที่รอการเข้า Critical

Mutual Exclusion และ Critical Region

 Mutual Exclusion with busy
waiting : สภาวะที่โปรเซสรอ อยู่นอก
CR แต่ยังมีการครอบครองเวลาซีพียูอยู่
ทำาให้เสียประโยชน์โดยไม่ได้งานอะไรเลย
 การแก้ปัญหา busy waiting ทำาได้โดย
“ ”การ อินเทอร์รัพต์ ซึ่งมี 2 ประเภทคือ
 Clock interrupt : บอกซีพียูว่ารัน
ครับเวลาควันตัมแล้ว
 I/O interrupt : บอกซีพียูว่าโปรเซสที่
ถูกบล็อกนั้นทำางานกับ I/O เสร็จ

 การแก้ปัญหา busy waiting มี 5 วิธี
คือ
 Disable Interrupt
 Lock Variable
 Strict Alternation
 Peterson’s Solution
 TSL Instruction

Mutual Exclusion with busy
waiting
waiting
 Disable Interrupt
 เป็นการยกเลิกอินเทอร์รัพต์
 ซีพียูทำางานได้อย่างต่อเนื่องโดยไม่สนใจ
อินเทอร์รัพต์
 โปรเซสที่อยู่ใน CR ได้เอ็กซิคิวต์จนเสร็จ
เรียบร้อย ไม่เกิด Race Condition
 เมื่อออกจาก CR ไปแล้ว ซีพียูจึงสนใจอิน
เทอร์รัพต์
 ใส่คำาสั่ง Disable Interrupt ไว้ตอนต้น
ของโปรเซสก่อนเข้า CR

waiting
waiting
 ข้อเสียของวิธี Disable Interrupt
 ถ้าลืมใส่ Able Interrupt จะทำาให้โปร
เซสนั้นรันรวดเดียวจบ
 ไม่นิยมใน User Mode แต่นิยมใน
Kernel Mode
 คำาสั่ง Disable Interrupt มีผลเฉพาะ

waiting
waiting
 Lock Variable
 ใช้ซอฟต์แวร์ในการตรวจสอบการเกิด
Race Condition
 กำาหนดตัวแปรเพื่อเก็บสภาวะว่ามีโปรเซ
สอยู่ใน CR หรือไม่ โดย 0 แสดงว่าไม่มี
โปรเซสอยู่ ส่วน 1 แสดงว่ามีโปรเซสอยู่
 ตัวแปรที่เก็บสภาวะนี้เป็นตัวแปรแบบ
โกลบอล ที่ทุกโปรเซสสามารถเรียก
ใช้ได้ ทำาให้สามารถตรวจสอบสภาวะ
ก่อนเข้า CR ได้

Lock Variable
IF Lock = 0 Then
Set Lock = 1
เริ่มเข้า Critical Region
Else
Wait until Lock = 0
Critical Region
Set Lock = 0

waiting
waiting
 Strict Alternation
 ใช้การสลับการเข้า CR ของโปรเซส 2
โปรเซส
 กำาหนดตัวแปรที่ทำาให้เกิดการสลับกัน
เข้า CR ของโปรเซส เรื่อยไปจนกว่างาน
จะเสร็จ
 ข้อเสีย :
 ใช้ได้เฉพาะ โปรเซส 2 โปรเซสเท่านั้น
 เกิด busy waiting ซึ่งยังคงใช้ซีพียูอยู่
แต่ไม่เกิดประโยชน์

Strict Alternation
While (TRUE) {
While (turn !=0) /*loop*/
Critical_Region();
turn = 1;
noncritical_region();
}
While (TRUE) {
While (turn !=1) /*loo
Critical_Region();
turn = 0;
noncritical_region();
}
Process A Process B

waiting
waiting
 มีการแชร์ตัวแปร (turn) และมี 2 โปรซีเดอร์
(enter_region และ leave_region) โดย
ใช้หมายเลขโปรเซสของตนเองเป็น
พารามิเตอร์
 การเรียก enter_region ทำาให้เกิดการรอ
จนกว่าจะปลอดภัยในการเข้า เมื่อใช้ตัวแปร
ที่แชร์นี้เสร็จแล้ว จะเรียก leave_region
เพื่อแจ้งให้โปรเซสอื่นทราบว่าทำางานเสร็จ
แล้ว และยอมให้โปรเซสอื่นเข้าได้
 เช่น ถ้าโปรเซส 0 เข้า CR จะกำาหนดค่า

waiting
waiting
 ถ้าโปรเซสทั้งสองเรียก enter_region
พร้อมกัน โปรเซสทั้งสองจะเก็บค่าลงใน
turn เมื่อเก็บค่าเสร็จค่าเก่าจะหายไป
 เช่น ถ้าโปรเซส 1 เก็บค่าหลังสุด ค่า
turn=1 เมื่อโปรเซสทั้งสองมาถึง
while โปรเซส 0 จะเอ็กซิคิวต์ 0 ครั้ง
และเข้า CR ในขณะที่โปรเซส 1 ยังไม่
เข้า CR จะรอจนกว่าโปรเซส 0 ออก
จาก CR

Peterson’s Solution
Int tern;
Int interested[N]; /*กำาหนดค่าเริ่มต้นทุก
ค่าเป็น 0 (False) */
Void enter_region(int process); /*
process เป็น 0 หรือ 1 */
{
int other; /* จำานวน
process อื่น */
other = 1 – other /* ค่าตรง
ข้ามของ process */
interested[process] = True;

Peterson’s Solution (ต่อ)
Void leave_region(int process);
{
interested[process] = False;
}

Peterson’s Solution
(Version 2)enter_region(int i)
{ while(true)
{
flag[i] =true; /*process i use CR
turn = j;
while(flag[j] && turn==j)
}
}
leave_region(int i)
{
flag[i] = false;
/* process i move o
from CR */
}

Peterson’s Solution (Version
3)

waiting
waiting
 TSL Instruction (Test Set Lock
Instruction)
 ช่วยแก้ปัญหา Lock Variable โดยทำา
Test Set Lock ใน ขั้นตอนเดียวกัน
 อ่านค่าจากหน่วยความจำามาเก็บในรีจิส
เตอร์ แล้ว Set ค่าในหน่วยความจำาเป็น 1
 การอ่านและการเก็บค่าในหน่วยความจำา
ทำาให้โปรเซสเซอร์ไม่สามารถใช้หน่วย
ความจำาตรงนั้นได้จนกว่าคำาสั่งจะเสร็จสิ้น
 ซีพียูใช้ TSL เพื่อล็อกไม่ให้ซีพียูอื่นใช้

waiting
waiting
 TSL Instruction (Test Set Lock
Instruction)
 การใช้คำาสั่ง TSL จะต้องแชร์ตัวแปร
Lock ในการใช้หน่วยความจำาที่แชร์
 เมื่อตัวแปร Lock มีการค่าเป็น 0 โปรเซ
สอื่นจะเซ็ตให้เป็น 1 เพื่อจะใช้คำาสั่ง
TSL แล้วทำาการอ่านหรือเขียนหน่วย
ความจำาที่แชร์ เมื่อทำางานเสร็จจะเปลี่ยน
ค่าเป็น 0 เหมือนเดิม โดยใช้คำาสั่ง
Move

waiting
waiting TSL Instruction (Test Set Lock
Instruction)
 เมื่อโปรเซสต้องการเข้า CR จะเรียก
enter_region แล้วก็อปปี้ค่าเดิมของ Lock
ไปไว้ที่รีจิสเตอร์ แล้วเซ็ต Lock=1
 เปรียบเทียบค่าเดิมกับ 0 ถ้าไม่ใช่ ค่า
Lock=1 แล้วกลับไปจุดเริ่มต้นเพื่อตรวจสอบ
อีกครั้ง
 จนกระทั่งเป็น 0 (เมื่อโปรเซสเข้า CR
เรียบร้อยแล้ว) รูทีนย่อยจะให้ค่า Lock=1
ในขณะที่การเคลียร์ค่าทำาได้โดยให้ค่า 0 กับ

TSL Instruction (Test Set
Lock Instruction)Enter_region:
TSL RX, LOCK / copy ค่าเดิมของ
LOCK ไปเก็บไว้ที่
register แล้วเซ็ตค่า LOCK เป็น 1
CMP RX, #0 / เปรียบเทียบค่าเดิมกับ
0
JNEEnter_region / ถ้าไม่ใช่ 0 จะกลับไปเริ่มต้น
เพื่อตรวจสอบอีกครั้ง
RET / Return ไปยังผู้เรียก
Leave_region:
MOVE LOCK, #0 / เก็บค่า 0 ใน LOCK
RET / Return ไปยังผู้เรียก

 Sleep and Wakeup
 การที่มีโปรเซสอยู่ใน CR โปรเซสอื่นยัง
ไม่อนุญาตให้เข้า CR ก็ต้องรอจนกว่า
โปรเซสนั้นจะออกมาเป็นสิ่งที่ถูกต้อง
 แต่บางครั้งสิทธ์การเข้า CR ไม่เท่ากัน
ทำาให้โปรเซสที่มีสิทธิ์สูงกว่าได้เข้าก่อน
(ถึงแม้โปรเซสอื่นจะมาก่อนก็ตาม)
 น่าจะใช้การบล็อกแทนการหยุดรอเพื่อ
เข้า CR
 การบล็อกที่ดีที่สุดคือ Sleep and

โครงสร้างพื้นฐานการซินโคร
ไนซ์
ไนซ์
 Sleep เป็น system call เพื่อบล็อกให้
โปรเซสหยุดทำางาน จนกว่าจะมีโปรเซ
สอื่นมาปลุก
 Wakeup เป็น system call ที่ปลุกให้
โปรเซสทำางานต่อ
 ทั้ง Sleep และ wakeup ทำางานสลับ
กัน จึงต้องมีการใช้พารามิเตอร์และ
แอ็ดเดรสของหน่วยความจำาที่สัมพันธ์
กัน

ไนซ์
ไนซ์
 ปัญหา Producer-Consumer เป็น
ตัวอย่างที่ง่ายที่สุดของ Sleep and
Wakeup
 ทั้ง 2 ส่วนจะแชร์บัฟเฟอร์ร่วมกันใน
ขนาดที่คงที่
 ในที่นี้สมมุติมี Producer และ
Consumer อย่างละ 1 ตัว
 Producer จะทำาหน้าที่ผลิตข้อมูลแล้วนำา
ไปเก็บไว้ในบัฟเฟอร์ และจะหยุดการผลิต

ไนซ์
ไนซ์
 Producer จะ Sleep ตัวเองเมื่อ
บัฟเฟอร์เต็ม และจะ Wakeup ให้
Consumer นำาข้อมูลไปใช้เมื่อมีข้อมูล
อย่างน้อย 1 ชุดในบัฟเฟอร์
 Consumer จะ Sleep ตัวเองเมื่อ
บัฟเฟอร์ว่าง และจะ Wakeup ให้
Producer ผลิตข้อมูลเมื่อนำาข้อมูลออก
ไปใช้ 1 ชุด หรือมากกว่า
 โดยที่ Sleep จะเป็นการเปลี่ยนสถานะจาก

ไนซ์
ไนซ์
 ขนาดของบัฟเฟอร์กำาหนดได้ด้วย
ตัวแปร count (สมมุติเก็บได้ N ชุด)
 ก่อนที่ Producer จะผลิต จะตรวจสอบ
ว่า count=N หรือไม่ ถ้าเป็น N ก็จะ
sleep ตัวเอง แต่ถ้ายังน้อยกว่า N จะ
ผลิตเพิ่มลงในบัฟเฟอร์ แล้วเพิ่มค่าตัว
แปร count
 ส่วน Consumer ถ้าต้องการใช้ข้อมูล
จะตรวจสอบ count=0 หรือไม่ ถ้าเป็น

Producer-Consumer Problem
(http://www.doc.ic.ac.uk/~jnm/concurre
ncy/classes/BoundedBuffer/
BoundedBuffer.html)#define N 100 /* ขนาด
buffer */
Int count = 0; /* จำานวน item
ใน buffer */
Void producer(void)
{ int item;
While(TRUE) { /* วนรอบ */
item = producer_item(); /* ผลิต
item ต่อไป */
If (count == N) sleep(); /* ถ้า
buffer เต็ม sleep ตัวเอง */
insert_item(item); /* ใส่ item ใน
buffer */

Producer-Consumer Problem
(ต่อ)
Void consumer(void)
{
int item;
While (TRUE) { /* วนรอบ */
If (count == 0) sleep(); /* ถ้า
buffer ว่าง sleep ตัวเอง */
item = remove_item(); /* นำา
item ออกจาก buffer */
count = count – 1; /* ลดค่าตัวแปร
count */
If (count <= N-1) wakeup(producer);
/* ถ้า buffer มีที่ว่างจะ
wakeup producer */

 Semaphore
 หลักการพื้นฐานคือมี process 2
process ขึ้นไป ประสานการทำางานกัน
โดยการส่งสัญญาณระหว่าง process
ผ่านทางตัวแปรพิเศษซึ่งเรียกว่า
semaphore
 ปฏิบัติการของ Semaphore เป็นปฏิบัติ
การเดียวที่ทำาให้ โปรเซสอื่นไม่สามารถ
แอ็กเซส Semaphore ได้จนกว่าจะ
เสร็จสมบูรณ์หรือถูกบล็อก ทำาให้ช่วย

 Semaphore
 Semaphores เป็นหลักการแก้ปัญหา
เขตวิกฤตที่มีความซับซ้อนมากยิ่งขึ้น
ซึ่งเป็นตัวแปรชนิด Integer ที่มีการ
บอกให้ Process ไหนได้เข้าทำางาน
ก่อน
 Semaphore S คือตัวแปรจำานวนเต็ม
ซึ่งหลังจากการกำาหนดค่าเริ่มต้นแล้ว จะ
ใช้งานได้ด้วยคำาสั่งซึ่งทำางานแบบครบ
หน่วย (คือแบ่งแยกไม่ได้) 2 คำาสั่ง คือ

Wait & Signal
Int s; /* Semaphore */
Void Wait(s) {
While (s <=0) /* do
nothing */
s --;
}
Void Signal(s) {
s ++;
}

 Semaphore
 Semaphore มี 2 ชนิดคือ Binary
Semaphore ที่มี 2 ค่าคือ 0 และ 1
เช่น mutex ที่ทำาหน้าที่ควบคุมการเข้า
CR หรือทำาให้เกิด Mutual Exclusion
 Counting Semaphore เป็น
Semaphore ตัวนับ ทำาหน้าที่ประสาน
จังหวะการทำางานระหว่าง Producer
และ Consumer ที่มี Full เป็นตัวนับ
จำานวนช่องข้อมูล และ Empty เป็นตัว

ตัวอย่างการเข้าใช้งาน
Semaphore Mutex

Mutex กับ Semaphore ต่างกัน
ยังไง?• เพื่อที่จะป้องกันปัญหาโลกเเตกในการเเยกกัน
ใช้งานทรัพยากรพร้อมกัน
(มันคงไม่ดีเเน่ถ้ามีใครอยากจะเข้ามา อึ พร้อม
กับ เราในห้องนำ้าห้องงเดียวกัน)
ถ้าลองเทียบ กับ สิ่งของในชีวิตประจำาวันเเล้ว
Mutex ก็เหมือนกับ สถานการณ์ที่ มีห้องนำ้าอยู่
1 ห้อง เเละมี
กุญเเจสำาหรับห้องนำ้าห้องนี้เพียง 1 อัน
ใครก็ตามที่อยากจะใช้ห้องนำ้า ก็ต้องรอจนกว่า
คนที่เข้าก่อนใช้ห้อง
นำ้าเสร็จ

[ ว่าง ] A B C D <=== นาย A B C D เกิด
ปวดอึ พร้อมกัน
[ A ] B C D <=== นาย A ได้เข้าห้องนำ้า
สบายใจเฉิบ
A [ B ] C D <=== จะเห็นว่าทุกคนต้องรอ
นาย A
เเต่ในกรณีของ Semaphore ฟังดูเข้าท่า
มากกว่า
Semaphore เปรียบเหมือน กุญเเจห้องนำ้า
จำานวนหนึ่งที่เหมือนกัน สมมุติว่ามี 4 อัน

ถ้ามีการใช้งานจน semaphore เหลือ 0 นั่น
ก็คือ ไม่มีที่พอให้ process ที่อื่นอีกต่อไป ซึ่ง
ก็จะต้องรอ ให้มีที่ว่าง
[ว่าง][ว่าง][ว่าง][ว่าง] A B C D E F G <===
นาย A B C D E F G เกิดปวดอึ พร้อมกัน
[A] [B ][C] [D ] E F G <=== นาย A B C D
สบายใจเฉิบ
C D [A] [B ][E] [F] G <=== เเต่ A B ท้อง
เสีย เเต่ E F ไม่ต้องรอนาน
ดังนั้น คำาถามที่ว่า Mutex ต่างกะ
Semaphore ยังไง ก็คือ Semaphore อนุ
ญาติให้ จำานวนของ process เข้าถึง

9. ปัญหาการทำางานของ
โปรเซส
โปรเซส
 The Dining Philosophers
Problem
(http://www.doc.ic.ac.uk/~jnm/concurre
ncy/classes/Diners/Diners.html)

โปรเซส
โปรเซส
Problem
 นักปราชญ์ 5 ท่านนั่งทานอาหารรอบ
โต๊ะกลม
 นักปราชญ์แต่ละท่านต้องใช้ตะเกียบทั้ง
2 ข้างซ้าย-ขวา
 เมื่อทานเสร็จในแต่ละรอบจะต้องวาง
ตะเกียบเพื่อให้นักปราชญ์ท่านอื่นได้
ทานบ้าง
 ถ้านักปราชญ์หยิบตะเกียบคนละข้าง

โปรเซส
โปรเซส
Problem
 เพื่อป้องกันปัญหาจะใช้ binary
semaphore ก่อนหยิบตะเกียบจะใช้
ปฏิบัติการ Wait() ในขณะที่ต้องการ
วางตะเกียบจะใช้ปฏิบัติการ Signal()
ส่วนข้อมูลที่ใช้ร่วมกันระหว่าง
process ทั้งหลาย คือ semaphore
fork[5];
 ปัญหานี้เป็นตัวอย่างที่สำาคัญของการ

The Dining Philosophers
ProblemDo {
Wait(fork[i]);
Wait(fork[(i+1) % 5);
/* eat */
Signal(fork[i]);
Signal(fork[(i+1) % 5);
/* think */
} While (True);

i fork[i]
fork[(i+1) % 5]
0 0 1
1 1
2
2 2
3
3 3
4

โปรเซส
โปรเซส
 The Readers-Writers Problem
(http://www.doc.ic.ac.uk/~jnm/concurr
ency/classes/ReadWriteLock/
ReadWriteLock.html)

โปรเซส
โปรเซส The Readers-Writers Problem
 มี 2 โปรเซสที่ทำางานร่วมกันคือโปรเซ
สอ่านข้อมูล และ โปรเซสเขียนข้อมูล
 การอ่านและการเขียนสามารถมีได้
หลายโปรเซสพร้อมกัน เช่น ระบบ
สำารองที่นั่งโดยสารเครื่องบิน
 โปรเซสการอ่านสามารถทำาได้ครั้งละ
หลาย ๆ โปรเซส ส่วนการเขียนจะ
กระทำาได้เพียงโปรเซสเดียวในเวลานั้น
 การใช้ Monitor หรือการซินโครไนซ์
อื่น ๆ ไม่สามารถจัดการ Mutual

โปรเซส
โปรเซส
 The Readers-Writers Problem
 ต้องคำานึงการรอคอยด้วย เพราะผู้อ่าน
สามารถอ่านข้อมูลได้ตลอดเวลา ถ้ามีผู้
อ่านเข้ามาตลอดเวลา ผู้เขียนก็จะไม่
สามารถทำางานได้ หรือถ้าเราให้สิทธิ์ผู้
เขียนมากกว่า ก็จะทำาให้ผู้อ่านไม่
สามารถอ่านข้อมูลได้
 การแก้ปัญหาต้องใช้การจัดคิว ถ้ามีผู้
เขียนอยู่ก่อนแล้ว มีผู้อ่านเข้ามาก็ต้อง
รอก่อน จะทำาให้ทั้งผู้อ่านและผู้เขียนไม่

 The Readers-Writers
Problem
 แบ่งปัญหาเรื่องของการรอคอยไม่มีที่สิ้นสุด
(Starvation) ได้เป็น 2 ลักษณะ คือ
 Writer Starvation ผู้เขียนรอไม่มีที่สิ้น
สุด เนื่องมาจากมีผู้อ่านเข้าไปอ่านข้อมูลกี่
คนก็ได้ และไม่ยอมออกมาสักที แต่ถ้ามีผู้
อ่านใหม่มาก็สามารถที่จะเข้าไปอ่านได้
 Reader Starvation ผู้อ่านรอไม่มีสิ้น
สุด เนื่องมาจากมีผู้เขียนเข้าไปเขียนข้อมูล
โปรเซส
โปรเซส

The Readers-Writers Problem
Semaphore mutex = 1, /* ตัวแปรของ
reader process
writing = 1; /* ตัวแปรของ writer
process
Int readerCounter = 0; /* ตัวแปรนับ
จำานวนคนอ่าน
Void writer(int)
{
Wait (writing); /* รับสิทธิ์การใช้
ฐานข้อมูล */
/* perform writing */

The Readers-Writers Problem
Void reader(int i) {
Wait(mutex); /* รับสิทธิ์ */
readerCounter++; /* มีผู้อ่านเพิ่มขึ้น 1
คน */
If (readerCounter == 1) /* ตรวจสอบว่า
เป็นผู้อ่านคนแรกหรือไม่ */
Wait(writing); /* รับสิทธิ์ให้ผู้เขียน
โดยใช้ writing */
Signal(mutex); /* ปล่อยสิทธิ์
*/
/* perform reading */
Wait(mutex); /* รับสิทธิ์ */
readerCounter--; /* ผู้อ่านลดลง 1 คน
*/

10. Thread10. Thread
 Thread (สายงาน) เป็นส่วนย่อยของโปรเซสที่
เรียกว่า “Lightweight Process” หมายถึง
หน่วยการทำางานของหน่วยประมวลผล
 Thread เป็นส่วนหนึ่งของ Process โดย
Process หนึ่งๆ อาจมีมากกว่าหนึ่ง Thread
(Multithreading)
 โปรแกรมประยุกต์บนคอมพิวเตอร์สมัยใหม่จะ
ทำางานแบบหลายสายงาน นั่นคือ 1 process
แต่มีหลาย Thread ทำาให้สามารถทำางานหลาย
อย่างได้คล้ายกับพร้อมๆกัน เช่น ในโปรแกรม
Word ระหว่างที่พิมพ์เอกสารออกเครื่องพิมพ์ ผู้

 1 Process , 1 Thread => MS DOS
 > 1 Process , 1 Thread => UNIX
 1 Process , > 1 Thread => Java Runtime
Environment (JRE)
 > 1 Process , > 1 Thread => Solaris,
Windows2000, Linux, OS/2

3 process และควบคุมเพียง 1 Thread1 Process ควบคุม 3 Thread

 ส่วนประกอบของ Thread
 หมายเลข Thread
 ตัวนับ : ติดตามให้ทราบคำาสั่งต่อไปที่จะ
เอ็กซิคิวต์
 ชุดของรีจิสเตอร์ : เก็บค่าตัวแปรที่
ทำางานอยู่
 สแต็ก : เก็บประวัติการเอ็กซิคิวต์

 ภายในโปรเซสที่ประกอบด้วย
Thread จะมีการแชร์รีซอร์ส
 ถ้า 1 โปรเซสควบคุม 1 Thread จะ
เรียกว่า “Single-threaded” แต่ถ้า 1
โปรเซสควบคุมหลาย thread จะเรียก
ว่า “Multithreaded”
 โปรแกรมสมัยใหม่เช่น เว็บบราวเซอร์
มี thread กำาลังแสดงรูปภาพ ในขณะ

 ข้อได้เปรียบของ Multithreaded
 การตอบสนอง
 การแชร์รีซอร์ส
 ความประหยัด
 การเอื้อประโยชน์ของสถาปัตยกรรม
มัลติโปรเซสเซอร์

 การสนับสนุนของ Thread
 User Thread : สนับสนุนจาก Kernel
ด้านบน และอยู่ในไลบรารีของ thread ใน
ระดับผู้ใช้ ไลบรารีสนับสนุนการสร้าง, จัด
เวลา และจัดการ thread โดยไม่ต้องได้รับ
การสนับสนุนจาก kernel เนื่องจาก Kernel
ไม่ต้องยุ่งเกี่ยวกับ Thread ระดับผู้ใช้ การ
จัดการ thread จะทำาในพื้นที่ของผู้ใช้โดย
ไม่จำาเป็นต้องใช้ Kernel ทำาให้ thread ใน
ระดับผู้ใช้นี้สามารถสร้างและจัดการได้อย่าง
รวดเร็ว ถ้า kernel เป็น single thread

 การสนับสนุนของ Thread
 Kernel Thread : ได้รับการสนับสนุน
โดยตรงจากระบบปฏิบัติการ โดยจะสร้าง,
จัดเวลา และจัดการ thread ภายใน Kernel
เอง เนื่องจากได้รับการสนับสนุนจากระบบ
ปฏิบัติการ ทำาให้ Kernel thread สร้างและ
จัดการได้ช้ากว่า user thread แต่เนื่องจาก
kernel จัดการเกี่ยวกับ thread เอง ดังนั้น
ถ้า thread เกิดการบล็อก system call จะ
ทำาให้ kernel นั้นดึง thread อื่นเข้าไปเอ็ก
ซิคิวต์แทนได้ จะไม่ทำาให้ thread อื่นของ

 โมเดลของ
MultiThread
 Many-to-One :
1 Kernel กับ
หลาย User
thread การ
จัดการ
threadอยู่ใน
พื้นที่ของผู้ใช้ซึ่งมี
ประสิทธิภาพ แต่

MultiThread
 One-to-One : 1
Kernel กับ 1 User
thread ทำางานได้
พร้อมกันดีกว่าแบบ
แรก โดยยอมให้
thread อื่นรันได้
เมื่อมี thread ถูก
บล็อก system call
ต้องคำานึงการสร้าง

MultiThread
 Many-to-many :
User thread มากกว่า
หรือเท่ากับ Kernel
thread ได้
 kernel thread กำา
หนดแอปพลิเคชัน
 Many-to-One ยอมให้
ผู้พัฒนา สร้าง user

 โมเดลของ MultiThread
 Many-to-many : User thread มากว่า
หรือเท่ากับ Kernel thread ก็ได้
 One-to-One ยอมให้รันพร้อมกันได้ ผู้
พัฒนาระวังอย่าสร้าง thread มากเกินไป
 ลดข้อจำากัดของโมเดลทั้งสอง
 ผู้พัฒนาสร้าง thread ได้เท่าที่จำาเป็น
และสัมพันธ์กับ Kernel
 สามารถรันแบบขนานในระบบมัลติ
โปรเซสเซอร์
 เมื่อ thread เกิดการบล็อก system call

 การยกเลิก Thread
 เป็นการทำาให้ thread จบการทำางาน
ก่อนจะเสร็จสมบูรณ์
 thread ที่ถูกยกเลิก เรียกว่า target
thread
 การยกเลิกมี 2 รููปแบบ
 Asynchronous : thread อื่นสั่งให้
target thread หยุดทันที
 Deferred : target thread ตรวจสอบ
ตัวเองว่าตนเองจะถูกยกเลิกหรือไม่ ถ้า

 การยกเลิก Thread
 ใน Deferred จะมี thread หนึ่ง
กำาหนดว่า target thread ใดถูก
ยกเลิก ซึ่ง target thread ตรวจสอบ
ตัวเอง การที่ยอมให้ thread ตรวจสอบ
เพื่อยกเลิกในจุดที่ความปลอดภัย
 จุดนี้ใน Pthread API เรียกว่า
Cancellation Point
 ส่วนมากระบบปฏิบัติการยอมให้ยกเลิก
แบบ Asynchronous

• เป็นมาตรฐานที่เสนอโดยคณะทำางานกำาหนด
มาตรฐานเพื่อให้โปรแกรมใช้ได้หลายระบบ
• Thread ซึ่งใช้ชุดคำาสั่งที่กำาหนดโดย
POSIX เรียกว่า Pthread
• ตามมาตรฐานของ POSIX แต่ละ Thread
จะมีชุด register, stack และการกำาหนด
สัญญาณของตนเอง และทุก Thread
ภายใน Process หนึ่งๆ สามารถใช้งานข้อ
มูลอื่นๆของ Process นั้นได้
POSIX (Portable
Operating Systems
Interface for Computing
Environments)
POSIX (Portable
Operating Systems
Interface for Computing
Environments)

แบบฝึกหัด
1. ในการแข่งขันรถ F1 ครั้งหนึ่ง ซึ่งมีรถเข้า
แข่งขันทั้งหมด 3 คันมาจากค่ายรถ 3 ค่าย
คือ Honda, Toyota และ Benz นายสม
ศักดิ์เป็นผู้เข้าแข่งขันเพียงคนเดียวในครั้งนี้
โดยนายสมศักดิ์ได้นำารถทั้ง 3 คันเข้าสู่จุด
ปล่อยตัว หลังจากนั้นนายสมศักดิ์ก็ทำาการ
สตาร์ทเครื่องยนต์ของรถทั้ง 3 คัน นายสม
ศักดิ์ทำาการขับรถ Honda ก่อน หลังจาก
ขับไปได้ประมาณ ¼ ของทาง นายสมศักดิ์
ก็ได้หยุดรถ Honda และได้วิ่งกลับมาขับ
รถ Toyota ออกไป ต่อมา หลังจากขับรถ
Toyota ไปได้ ½ ของทาง ปรากฏว่ารถ

จากเรื่องราวทั้งหมด ถ้าเปรียบเทียบกับการ
ทำางานของระบบคอมพิวเตอร์ให้ตอบคำาถามต่อ
ไปนี้
1.1) อะไร คือ CPU
1.2) Resource ทั้งหมดมีอะไรบ้าง
1.3) Resource อะไรบ้างที่อยู่ใน New State
อธิบายด้วยว่าตอนไหน
1.4) Resource อะไรบ้างที่อยู่ใน Ready State
อธิบายด้วยว่าตอนไหน
1.5) Resource อะไรบ้างที่อยู่ใน Run State
(แยก Resource แต่ละตัว และบอกว่าแต่ละ

2. พิจารณา InterProcess-
Communication ระหว่าง Process P
(ผู้รับ) และ Process Q (ผู้ส่ง)
2.1) ถ้าการสื่อสารเพื่อส่ง 1 Message
ระหว่าง 2 Process นี้เป็นแบบ Direct
Communication ให้เขียน Sequence
ของฟังก์ชัน Send และ Receive
2.2) จากข้อ 2.1) ให้เขียน sequence
ของการตรวจสอบการสูญหายของข้อมูล
2.3) ถ้าการสื่อสารเพื่อส่ง Message
ระหว่าง 2 Process นี้เป็นแบบ Indirect
Communication โดย Process P คอยรับ

Start
StopWhile(True)
Count == N
Sleep() insert_item(item)
Count = Count + 1
Count >= 1
Wakeup(consumer)
item = produce_item()
FT
T
F
T
Flowchart of
Procedure Produc

Start
StopWhile(True)
Count ==0
Sleep() item=remove_item()
Count = Count- 1
Count <=N-1
Wakeup(producer)
Cousume_item(item)
FT
T
F
T
Flowchart of
Procedure Consum

Os ch02

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Os ch02 (20)

Os ch02