Os Ch02 Process

บทที่ 2
โปรเซส และ Thread
ระบบปฏิบต
ั ก
ิ าร (Operating Systems) 1
ความหมายของโปรเซส
ความหมายของโปรเซส
 โปรแกรมทีกำ ่ ลังถูกเอ็กซคิ วิ ต์
 โปรแกรมทีกำ ่ ลังทำงานอยู่
 กิจกรรมทีม ่ ก ั พันธ์กน
ี ารทำงานสม ั
 สงิ่ ทีกำ ้
่ ลังใชงานโปรเซสเซอร์ อยู่
ั ก
องค
องคป ์ ระกอบของโปรเซส
์ป ระกอบของโปรเซส
 หมายเลขโปรเซส (Process ID)
 โค ้ดโปรแกรม (Program Code)
 ข ้อมูล (Data)
 บล็อกควบคุมโปรเซส (Process Control Block ) หรือ PCBเป็ นเนื ้อที่
ของหน่วยความจำที่ระบบปฏิบตั ิการกำหนดไว้ เพื่อเก็บข้ อมูลที่สำคัญของโปรเซส
 PSW (Program Status Word) เป็ นตัวควบคุมลำดับการเอ็กซิคิวต์
 คุณสมบัตข ิ องโปรเซส
 ลำดับความสำคัญของโปรเซส (Priority)
 อำนาจหน ้าทีข ่ องโปรเซส (Authority)
 คุณสมบัตอ ิ น
ื่ ๆ
ั ก
บล็
บล็ออกควบคุ
กควบคุมมโปรเซส
โปรเซส (PCB)
(PCB)
ข้ อมูลใน PCB ของโปรเซสประกอบด้ วย
 พอยเตอร์ (Pointer)
 สถานะของโปรเซส (Process state)
 หมายเลขของโปรเซส (Process ID)
 ตัวนั บจำนวน (Program counter)
 รีจส ิ เตอร์ (Register)
 ข ้อมูลการจัดการเวลาของซพ ี ย
ี ู (CPU scheduling information)
 ข ้อมูลการจัดการหน่วยความจำ (Memory management
information)
 ข ้อมูลแอ็กเคาต์ (Account information)
 ข ้อมูลสถานะอินพุต/เอาต์พต ุ (I/O status information)
ั ก
บล็อกควบคุมโปรเซส
ั ก
(PCB)
สถานะของโปรเซส
สถานะของโปรเซส
 สถานะเริม่ ต ้น (New)
 สถานะพร ้อม (Ready)
 สถานะรัน (Run)
 สถานะรอ,พัก (Wait)
 สถานะบล็อก (Block)หรื ออินเทอร์ รัพต์
 สถานะสนิ้ สุด (Terminate)
ั ก
ไดอะแกรมของสถานะ
โปรเซส
ั ก
การจ
การจั ดเวลาโปรเซส
ั ดเวลาโปรเซส
 ใชในระบบมัลติโปรแกรมมิ่ง คือการจัดโปรเซสใหรันตลอดเวลา เพื่อ
ใหใชประโยชนซีพียไู ดสูงสุด
 โปรเซสที่ระบบปฏิบตั ิการสรางขึ ้นมาใหมจะอยูในสถานะพรอมและ
เก็บ อยูในคิว เรี ยกวา Ready Queue เพื่อรอการรัน
 ต้ องพิจารณาหน่วยความจำของระบบมีเพียงพอหรื อไม่
 Ready Queue จะเก็บโปรเซสในลักษณะลิงคลิสต (Link list) ที่สวนหัว
ของคิว จะประกอบดวยพอยเตอรของ PCB เริ่ มตนและทายสุดของ
ลิสต และแตละ PCB จะมีพอยเตอรชี ้ไปยัง PCB ตัวตอไปของคิว
ั ก
หัว
ท้าย
คิวที่พร้อมทำงานและ
ระบบปฏิบต ิ ารอิ(Operating
ั ก นพุต/เอาต ์ ุตอื่น ๆ
พ
Systems) 9
การจ
การจั ดเวลาโปรเซส
ั ดเวลาโปรเซส
ปญหา : หากมีโปรเซสใดตองใชเวลานาน ๆ จะทำใหโปรเซ

สอื่นที่อยูในคิวตองเสียเวลารอนานเกินไป
วิธีแกไข : กำหนดเวลาในการอยูในสถานะรันของโปรเซสทุกโปร
เซส เรี ยกวาเวลาควันตัม (Quantum time) ถ้ าเกินจะไปต่อคิวใหม่
ั ก
โปรเซสที่ใชเ้ วลาเกินเวลาควันตัมจะยา้ ยไปตอ่ คิว
ใหม่
การบล็อกโปรเซสเมือ ่ ต ้องการใช ้ I/O หรือมีการ

ั ก อินเทอร์
ิ าร (Operating รัพต์
Systems) 11
ดี
ดีไไวซ
วซค์ค
์ วิ วิ (Device
(Device Queue)
Queue)
คิวของโปรเซสที่รอการตอบสนองจากการใช้ อินพุต/เอาต์พตุ ดีไวซ์
ั ก
คอนเท็
คอนเท็ก กซซส ์ส
์ วิวิต
ตช ช์ ์(Context
(Context
Switch)
Switch)
 เป็ นการสวิตช์ไปยังโปรเซสในคิวต่อไปเมื่อซีพีย ูทำงานโปรเซสนันเสร็
้ จ
เรี ยบร้ อยแล้ ว
 ระหว่างการสวิตช์จะไม่มีการทำงาน
 เวลาที่ใช้ ขึ ้นกับความเร็วของหน่วยความจำ, จำนวนรี จิสเตอร์ และคำ
สัง่ พิเศษในระบบ
 คอนเท็กซ์สวิตช์กลายเป็ นสิง่ ที่เพิ่มประสิทธิภาพที่โครงสร้ างใหม่เรี ยกว่า
Thread นำมาใช้ เพื่อหลีกเลี่ยงปั ญหาคอขวดของระบบ
ั ก
โอเปอเรช ันของโปรเซส
โอเปอเรชนของโปรเซส
ั
 การสร้ างโปรเซส
 การสร้ างโปรเซสจะกระทำผ่าน System Call โปรเซสที่สร้ างเรี ยกว่า
“โปรเซสแม่” (Parent Process)
 ถ้ าเป็ นการสร้ างในขณะเอ็กซิคิวต์โปรเซสจะเรี ยกว่า “โปรเซสลูก”
(Children Process)
 โปรเซสลูกอาจจะใช้ รีซอร์ สจากระบบปฏิบตั ิการหรื อผ่านทาง
โปรเซสแม่ก็ได้
 โปรเซสแม่อาจจะแบ่งรี ซอร์ สเป็ นส่วนย่อย ๆ หรื อแชร์ รีซอร์ สให้ โปร
เซสลูกก็ได้
ั ก
ั
 การเอ็กซิคิวต์ (พร้ อมกัน หรื อรอให้ โปรเซสลูกเสร็จก่อนแม่จงึ เอ็กซิคิวต์ )

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

 ความสะดวก : ผู้ใช้ ต้องการทำงานหลายอย่างในเวลาเดียวกัน
 กลไกที่สนับสนุนให้ โปรเซสสามารถประสานกันได้ คือ การติดต่อ
ระหว่างโปรเซส (InterProcess Communication) และการซินโคร
ไนซ์โปรเซส (Synchronize Process)
ั ก
การติ
การติด ดต่
ต่ออระหว่
ระหว่าางโปรเซส
งโปรเซส
 โครงสร้ างพื ้นฐาน
(IPC)
(IPC)
 วิธีการติดต่อ
 การจัดบัฟเฟอร์
 เงื่อนไขยกเว้ น
ั ก
โครงสร้
โครงสร้ าางพื
งพื ้นฐาน
้นฐาน
 IPC (InterProcess Communication)สนับสนุนกลไกเพื่อให้ โปรเซสสามารถติดต่อ
ซึง่ กันและกันได้ อย่างมีประสิทธิภาพ ได้ แก่ ระบบแมสเสจ (Message system)
 ฟั งก์ชนั ของระบบแมสเสจที่ IPC สนับสนุนมีอย่างน้ อย 2 ประการคือ การส่งข้ อมูล
(Send message) และรับข้ อมูล (Receive message)
 เมื่อโปรเซสใดต้ องการข้ อมูลจากโปรเซสอื่นจะส่งคำร้ องขอไปยังโปรเซสนัน้ โปรเซส
ที่ถกู ร้ องขอจะส่งข้ อมูลนันไปให้
้
 ขนาดของข้ อมูลอาจจะมีขนาดคงที่ หรื อขนาดไม่คงที่ก็ได้
 ก่อนการรับ-ส่งข้ อมูลจะต้ องมีการสร้ างลิงค์ให้ พร้ อมก่อน ทังลิ
้ งค์ทางกายภาพ (เช่น
การแชร์ หน่วยความจำ, บัส หรื อเน็ตเวิร์คก็ได้ ) และลิงค์ทางลอจิก
ั ก
คุคุณ
ณสมบ
สมบั ติ
ั ติขของลิ
องลิงงคคท์ างลอจิ
์ท างลอจิกก
 จะสร้ างลิงค์อย่างไร
 ลิงค์ที่สร้ างนันสั
้ มพันธ์กบั โปรเซสมากกว่า 2 โปรเซสหรื อไม่
 ระหว่างโปรเซสทังสองจะมี
้ กี่ลงิ ค์
 ความจุของลิงค์เป็ นเท่าไร
 ลิงค์นนมี
ั ้ บพั เฟอร์ หรื อไม่ ถ้ ามีขนาดบัพเฟอร์ เป็ นเท่าไร
 ลิงค์เป็ นแบบทางเดียว(undirectional) หรื อสอง
ทิศทาง(bidirectional)
ั ก
ลิ
ลิงงค์
ค์แแบบลอจิ
บบลอจิกกและโอเปอเรช ั นใน
และโอเปอเรชนใน
ั
การร
การรับ-ส ่ง
ับ-สง่ แมเสจ
แมเสจ
 การติดต่อเป็ นแบบทางตรงหรื อทางอ้ อม
 การติดต่อเป็ นแบบสมมาตร หรื อไม่สมมาตร
 การติดต่อเป็ นแบบอัตโนมัติ หรื อใช้ บฟ
ั เฟอร์ เฉพาะแบบ
 การส่งแมสเสจเป็ นการส่งแบบสำเนา หรื ออ้ างอิง
 แมสเสจมีขนาดคงที่ หรื อไม่คงที่
ั ก
วิวิธธี กี การติ
ารติดดตต่อ่อระหว
ระหวา่ า่ งโปรเซส
 การติดต่ อทางตรง (Direct Communication) แต่ละโปรเซสที่
ต้ องการติดต่อกันจะต้ องกำหนดชื่อเฉพาะที่ใช้ ในการติดต่อทัง้
โปรเซสที่ต้องการรับ และโปรเซสที่ต้องการส่ง
Send (B,message) จะเป็ นการส่งแมสเสจไปยังโปรเซส B
Receive (A,message) จะเป็ นการรับแมสเสจจากโปรเซส A
การติดต่อแบบนี ้ระบบปฏิบตั ิการจะไม่ดำเนินการติดต่อให้ กบั
โปรเซสทังสองโปรเซส
้ โปรเซสทังสองจะต้
้ องจัดการเอง
ั ก
คุคุณ
ณสมบ
สมบั ติ
องลิงงคคข องวิธธี กี การ
์ องวิ
์ข าร
ติติดดตต่อ่อทางตรง
ทางตรง
 การสร้ างลิงค์จะเป็ นแบบอัตโนมัติระหว่างคูข่ องโปรเซสที่ต้องการ
ติดต่อโปรเซสจะทราบหมายเลขของโปรเซสที่จะติดต่อด้ วย
 ลิงค์หนึง่ ๆ จะมีความสัมพันธ์เฉพาะโปรเซสสองโปรเซสเท่านัน้
 ระหว่างโปรเซสแต่ละคูน่ นจะมี ั ้ เพียงลิงค์เดียวเท่านัน้
 ลิงค์นี ้เป็ นได้ ทงทิ
ั ้ ศทางเดียว และสองทิศทางแต่ปกติจะเป็ นแบบ
สองทิศทาง
ั ก
วิวิธธี กี การติ
ารติดดตต่อ่อระหว
 การติดต่ อทางอ้ อม (Indirect Communication) แต่ละโปรเซส
ที่ต้องการติดต่อจะต้ องติดต่อกันผ่านเมลล์บอ็ กซ์(Mailbox) หรื อ
อาจเรี ยกว่าเป็ นการติดต่อผ่านพอร์ ต (Port) แต่ละเมลล์บอ็ กซ์จะ
มีหมายเลขไม่ซ้ำกับเมลล์บอ็ กซ์อื่น
Send(B,message) เป็ นการส่งแมสเสจไปยังเมลล์บอ็ กซ์ B
Receive(A,message) เป็ นการรับแมสเสจจากเมลล์บอ็ กซ์ A
ั ก
คุคุณ
ณสมบ
สมบั ติ
องลิงงคคข องวิธธี กี การ
์ องวิ
์ข าร
ติติดดตต่อ่อทางอ
ทางอ้ อ้ อมม
 จะมีการสร้ างลิงค์ระหว่างโปรเซสที่มีการแชร์ เมลล์บอ็ กซ์เท่านัน้
 ลิงค์หนึง่ ๆ อาจจะมีความสัมพันธ์มากกว่าสองโปรเซสได้
 ระหว่างโปรเซสแต่ละคูน่ นอาจจะมี
ั้ หลายลิงค์ตา่ งกันได้ แต่ละ
ลิงค์จะมีเพียงเมลล์บอ็ กซ์เดียว
 การลิงค์อาจจะเป็ นทิศทางเดียว หรื อสองทิศทางก็ได้
ั ก
กลไกที่ ร่ ระบบปฏิ
กลไกที ะบบปฏิบบั ติั ติกการยอมให
ารยอมให้ โ้ โปรเซสจ
ปรเซสจั ดการ
ั ดการ
กกั บเมลล
ั บเมลลบ ์ ็อ็อกซ
์บ กซ์ ์
 สร้ างเมลล์บอ็ กซ์ใหม่
 ส่งและรับแมสเสจผ่านเมลล์บอ
็ กซ์
 ทำลายเมลล์บอ ็ กซ์
ั ก
รูรูปปแบบของเมลล
แบบของเมลลบ ์ ็อ็อกซ
์บ กซ์ ์
 เมลล์บอ็ กซ์แบบคิว ขนาดของเมลล์บอ็ กคงที่
ข้ อมูลเข้ า ข้ อมูลออก
เมลล์บอ็ กซ์ เมลล์บอ็ กซ์
FIFO (First In First Out)
ั ก
์บ กซ์ ์
 เมลล์บอ็ กซ์แบบไปป์ ขนาดเมลล์บอ็ กซ์ยืดหยุน่ ได้ ตามขนาดของ
ข้ อมูลที่ใส่
ข้ อมูลเข้ า ข้ อมูลออก
เมลล์บอ็ กซ์ เมลล์บอ็ กซ์
FIFO (First In First Out)
ั ก
์บ กซ์ ์
 เมลล์บอ็ กซ์แบบสแต็ก
ข้ อมูลเข้ า
เมลล์บอ็ กซ์
ข้ อมูลออก FILO (First In Last Out)

เมลล์บอ็ กซ์
ั ก
การจั
การจัดดบับัฟฟเฟอร์
เฟอร์ (Buffer)
(Buffer)
บัฟเฟอร์ คือคิวของแมสเสจที่ผกู ติดกับลิงค์ โดยพื ้นฐานจะมี
ความจุ 3 ลักษณะ
 ความจุศนู ย์ (Zero Capacity) : ในลิงค์จะไม่มีแมสเสจรอ
อยูเ่ ลย
 ความจุแบบมีขอบเขต (Bounded capacity) : จำนวนของ
แมสเสจในลิงค์จะมีได้ ไม่เกินจำนวนที่กำหนด
 ความจุไม่มีขอบเขต (Unbounded capacity) : จำนวนของ
แมสเสจในลิงค์จะมีได้ ไม่จำกัด
ั ก
การ Asynchronous ระหว่
การ Asynchronous ระหว่าางโปรเซส
งโปรเซส PP
และโปรเซส
และโปรเซส QQ
Process P…
send(Q,message);
receive(Q,message);
Process Q…
receive(P,message);
send(P,”Acknowledgment”)
ั ก
เงื่ อ่ อนไขยกเว
เงื นไขยกเว้ น ้ นในการติ
ในการติดดตต่อ่อ
ระหว
 การสิ ้นสุดของโปรเซส
ถ้ าผู้รับหรื อผู้สง่ แมสเสจสิ ้นสุดก่อนแมสเสจจะเอ็กซิคิว
ต์ ทำให้ แมสเสจถูกกำจัดทำให้ ผ้ รู ับไม่ได้ รับแมสเสจ หรื อผู้
ส่งไม่ได้ สง่ แมสเสจ
ั ก
เงื่ อ่ อนไขยกเว
เงื นไขยกเว้ น ้ นในการติ
ในการติดดตต่อ่อ
ระหว
 การสูญหายของแมสเสจ
แมสเสจจากโปรเซส P ที่สง่ ไปยังโปรเซส Q อาจจะสูญหาย
ระหว่างทางของการสื่อสารก็ได้ ซึง่ อาจจะเป็ นข้ อผิดพลาดด้ าน
ฮาร์ ดแวร์ หรื อสายสื่อสาร มี 3 วิธีพื ้นฐานในการจัดการ
 OS มีหน้ าที่รับผิดชอบในการตรวจสอบการสูญหายนี ้เพื่อส่งแมสเสจใหม่
 โปรเซสที่ทำหน้ าที่สง่ แมสเสจมีหน้ าที่รับผิดชอบในการตรวจสอบการ
สูญหายเพื่อส่งแมสเสจใหม่ถ้าต้ องการอีก
 OS มีหน้ าที่รับผิดชอบในการตรวจสอบการสูญหายนี ้หลังจากนันจะแจ้ ้ ง
ให้ โปรเซสที่ทำหน้ าที่สง่ แมสเสจที่เกิดการสูญหายทำหน้ าที่สง่ ใหม่
ั ก
การซ
การซน ิน โครไนซโ์ โ์ ปรเซส
ิ โครไนซ ปรเซส (Process
(Process
Synchronization)
Synchronization)
 โปรเซสที่มีความเป็ นอิสระกันเรี ยกว่า Asynchronous
 โปรเซสที่มีความเกี่ยวข้ องกันเรี ยกว่า Synchronous
 การซินโครไนซ์โปรเซสหรื อการเข้ าจังหวะของโปรเซส หมายถึง
การทำงานของโปรเซส 2 โปรเซสที่มีความเกี่ยวข้ องกัน เนื่องจาก

 ต้ องการใช้ รีซอร์ สร่วมกัน หรื อ
 อาจจะเป็ นการเอ็กซิคิวต์โปรเซสหลังจากที่โปรเซสอื่น เอ็กซิคิว
ต์เสร็จแล้ ว
ั ก
A B
การซินโครไนซ์โปรเซส
ั ก
10 X=10 10 X=10
X-->X+10 A X-->X-10 B
X=20 X=0
20 0
X=20 X=0
X-->X-10 B X-->X+10 A
10 X=10 10 X=10
โปรเซส A ทำงานก่อนโปรเซส B โปรเซส B ทำงานก่อนโปรเซส A
ั ก
10
X=10 X=10
A X-->X+10 X-->X-10 B
X=20 X=0
20 หรือ 0
โปรเซส A และโปรเซส B ทำงานพร้ อมกัน
ั ก
โครงสร้าางพื งพืน้น
้ ฐานการซ
ฐานการซน ิน
ิ โคร
โคร
ไนซ์ ์
ไนซ
 Race Condition : สภาวะที่เกิดข้ อผิดพลาดเนื่องจากโปรเซส
ทำงานร่วมกันซึง่ มีการใชัรีซอร์ สร่วมกัน
 Mutual Exclusion : เป็ นการกีดกันไม่ให้ โปรเซสอื่นเข้ ามาใช้
รี ซอร์ สในขณะที่มีโปรเซสอื่นครอบครองรี ซอร์ สนันอยู
้ ่ บริ เวณหรื อ
ส่วนของโปรแกรมที่โปรเซสครอบครองรี ซอร์ สนันอยู ้ ่ เรี ยกว่า
Critical Region หรื อ Critical Section
 อาจกล่าวได้ วา่ ถ้ ามีโปรเซสใดอยูใ่ น Critical Region แล้ วโปรเซ
สอื่นจะเข้ าไปอยูใ่ น CR อีกไม่ได้ จนกว่าโปรเซสเดิมนันจะออกไป
้
ั ก
โครงสร้าางพืงพืน ้น
ฐานการซนิน
ิ โคร
โคร
ไนซ์ ์
ไนซ
 คุณสมบัติของ Mutual Exclusion
 ต้ องไม่มีโปรเซส 2 โปรเซสอยูใ่ น Critical Region พร้ อมกัน
 ต้ องไม่มีสมมุติฐานและข้ อจำกัดเกี่ยวกับความเร็ ว และ
จำนวนซีพียมู าเกี่ยวข้ อง
 ต้ องไม่มีโปรเซสใด ๆ ภายนอก Critical Region ที่บล็อกการ
ทำงานของโปรเซสอื่น
 ต้ องไม่มีโปรเซสใดที่รอการเข้ า Critical Region ตลอดเวลา
ั ก
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
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 Disable Interrupt
 เป็ นการยกเลิกอินเทอร์ รัพต์
 ซีพียทำ
ู งานได้ อย่างต่อเนื่องโดยไม่สนใจอินเทอร์ รัพต์
 โปรเซสที่อยูใ่ น CR ได้ เอ็กซิคิวต์จนเสร็ จเรี ยบร้ อย ไม่เกิด Race
Condition
 เมื่อออกจาก CR ไปแล้ ว ซีพียจ ู งึ สนใจอินเทอร์ รัพต์
 ใส่คำสัง่ Disable Interrupt ไว้ ตอนต้ นของโปรเซสก่อนเข้ า CR
 ใช้ คำสัง่ Able Interrupt ไว้ ตอนท้ ายก่อนออกจาก CR
ั ก
Mutual
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 ข้ อเสียของวิธี Disable Interrupt

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

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

 ตัวแปรที่เก็บสภาวะนี ้เป็ นตัวแปรแบบโกลบอล ที่ทก ุ โปรเซสสามารถ
เรี ยกใช้ ได้ ทำให้ สามารถตรวจสอบสภาวะก่อนเข้ า CR ได้
 ข้ อเสีย : ไม่ได้ ชว
่ ยแก้ Race Condition เนื่องจากเป็ นการแชร์ ข้อมูล
ด้ วย นัน่ เอง
ั ก
Mutual
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 Strict Alternation
 ใช้ การสลับการเข้ า CR ของโปรเซส 2 โปรเซส
 กำหนดตัวแปรที่ทำให้ เกิดการสลับกันเข้ า CR ของโปรเซส
เรื่ อยไปจนกว่างานจะเสร็จ
 ข้ อเสีย :
 ใช้ ได้ เฉพาะ โปรเซส 2 โปรเซสเท่านัน้
 เกิด busy waiting ซึง่ ยังคงใช้ ซีพียอ
ู ยู่ แต่ไม่เกิดประโยชน์
 ถ้ าเวลาที่ใช้ ในการประมวลของโปรเซสทังสองต่ ้ างกันมาก ทำให้
โปรเซสหนึง่ ไปขวางหรื อกีดกันไม่ให้ โปรเซสอื่นเข้ า CR ได้
ั ก
Mutual
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 มีการแชร์ ตวั แปร (turn) และมี 2 โปรซีเดอร์ (enter_region และ
leave_region) โดยใช้ หมายเลขโปรเซสของตนเองเป็ นพารามิเตอร์
 การเรี ยก enter_region ทำให้ เกิดการรอจนกว่าจะปลอดภัยในการ
เข้ า เมื่อใช้ ตวั แปรที่แชร์ นี ้เสร็จแล้ ว จะเรี ยก leave_region เพื่อแจ้ ง
ให้ โปรเซสอื่นทราบว่าทำงานเสร็จแล้ ว และยอมให้ โปรเซสอื่นเข้ าได้
 เช่น ถ้ าโปรเซส 0 เข้ า CR จะกำหนดค่า turn=0 ในขณะที่โปรเซส 1
เรี ยก enter_region จะรอจนกว่า interested[0] เป็ น False ซึง่ จะ
เกิดเมื่อโปรเซส 0 เรี ยก leave_region
ั ก
Mutual
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 ถ้ าโปรเซสทังสองเรี
้ ยก enter_region พร้ อมกัน โปรเซสทัง้
สองจะเก็บค่าลงใน turn เมื่อเก็บค่าเสร็จค่าเก่าจะหายไป
 เช่น ถ้ าโปรเซส 1 เก็บค่าหลังสุด ค่า turn=1 เมื่อโปรเซสทัง้
สองมาถึง while โปรเซส 0 จะเอ็กซิคิวต์ 0 ครัง้ และเข้ า CR

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

 ซีพียใู ช้ TSL เพื่อล็อกไม่ให้ ซีพียอ
ู ื่นใช้ หน่วยความจำนัน้
ั ก
Mutual
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 การใช้ คำสัง่ TSL จะต้ องแชร์ ตวั แปร Lock ในการใช้ หน่วย
ความจำที่แชร์
 เมื่อตัวแปร Lock มีการค่าเป็ น 0 โปรเซสอื่นจะเซ็ตให้ เป็ น 1
เพื่อจะใช้ คำสัง่ TSL แล้ วทำการอ่านหรื อเขียนหน่วยความ

จำที่แชร์ เมื่อทำงานเสร็จจะเปลี่ยนค่าเป็ น 0 เหมือนเดิม
โดยใช้ คำสัง่ Move
ั ก
Mutual
Mutual Exclusion
Exclusion with
with busy
busy waiting
waiting
 เมื่อโปรเซสต้ องการเข้ า CR จะเรี ยก enter_region แล้ วก็อปปี ค ้ า่ เดิมของ
Lock ไปไว้ ที่รีจิสเตอร์ แล้ วเซ็ต Lock=1
 เปรี ยบเทียบค่าเดิมกับ 0 ถ้ าไม่ใช่ ค่า Lock=1 แล้ วกลับไปจุดเริ่ มต้ นเพื่อตรวจ
สอบอีกครัง้
 จนกระทัง่ เป็ น 0 (เมื่อโปรเซสเข้ า CR เรี ยบร้ อยแล้ ว) รู ทีนย่อยจะให้ คา ่
Lock=1 ในขณะที่การเคลียร์ คา่ ทำได้ โดยให้ คา่ 0 กับ Lock
 รู ทีนย่อยทังสองจะทำงานทำงานสั
้ มพันธ์กนั ในช่วงเวลาที่เหมาะสม ก่อนเข้ า
CR โปรเซสจะเรี ยก enter_region เมื่อเสร็จจะเรี ยก leave_region ซึง่ ทำให้
Lock=0 เรื่ อยไป
ั ก
โครงสร้าางพื ้น
งพืน้ ฐานการซ
ิ โคร
โคร
ไนซ์ ์
ไนซ
 Sleep and Wakeup
 การที่มีโปรเซสอยูใ่ น CR โปรเซสอื่นยังไม่อนุญาตให้ เข้ า CR
ก็ต้องรอจนกว่าโปรเซสนันจะออกมาเป็
้ นสิง่ ที่ถกู ต้ อง
 แต่บางครัง้ สิทธ์ การเข้ า CR ไม่เท่ากัน ทำให้ โปรเซสที่มีสท ิ ธิ์
สูงกว่าได้ เข้ าก่อน (ถึงแม้ โปรเซสอื่นจะมาก่อนก็ตาม)
 น่าจะใช้ การบล็อกแทนการหยุดรอเพื่อเข้ า CR
 การบล็อกที่ดีที่สด ุ คือ Sleep and Wakeup
ั ก
งพืน้ ฐานการซ
ิ โคร
โคร
ไนซ์ ์
ไนซ
 Sleep เป็ น system call เพื่อบล็อกให้ โปรเซสหยุดทำงาน
จนกว่าจะมีโปรเซสอื่นมาปลุก
 Wakeup เป็ น system call ที่ปลุกให้ โปรเซสทำงานต่อ
 ทัง้ Sleep และ wakeup ทำงานสลับกัน จึงต้ องมีการใช้
พารามิเตอร์ และแอ็ดเดรสของหน่วยความจำที่สมั พันธ์กนั
ั ก
โครงสร้าางพื
งพืน้น
ิ โคร
โคร
ไนซไนซ์ ์
 ปั ญหา Producer-Consumer เป็ นตัวอย่างที่งา ่ ยที่สดุ ของ Sleep
and Wakeup
 ทัง้ 2 ส่วนจะแชร์ บฟ ั เฟอร์ ร่วมกันในขนาดที่คงที่
 ในที่นี ้สมมุติมี Producer และ Consumer อย่างละ 1 ตัว
 Producer จะทำหน้ าที่ผลิตข้ อมูลแล้ วนำไปเก็บไว้ ในบัฟเฟอร์
และจะหยุดการผลิตเมื่อบัฟเฟอร์ เต็ม
 Consumer จะนำข้ อมูลจากบัฟเฟอร์ ไปใช้ (ต้ องมีอย่างน้ อย 1
ชิ ้น) และจะหยุดเมื่อบัฟเฟอร์ วา่ ง
ั ก
งพืน้น
ิ โคร
โคร
 Producer จะ Sleep ตัวเองเมื่อบัฟเฟอร์ เต็ม และจะ Wakeup ให้
Consumer นำข้ อมูลไปใช้ เมื่อมีข้อมูลอย่างน้ อย 1 ชุดในบัฟเฟอร์

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

แล้ วเพิ่มค่าตัวแปร count
 ส่วน Consumer ถ้ าต้ องการใช้ ข้อมูล จะตรวจสอบ count=0 หรื อไม่
ถ้ าเป็ น 0 ก็จะ sleep ตัวเอง ถ้ าไม่ใช่ 0 ก็จะนำข้ อมูลไปใช้ แล้ วลด

ค่าตัวแปร count
ั ก
งพืน้น
ิ โคร
โคร
 Semaphore
 เป็ นตัวแปรจำนวนเต็มเพื่อนับจำนวน Wakeup
 ค่าเริ่ มต้ นเป็ น 0 แสดงว่าไม่มี Wakeup
 ถ้ าค่าเป็ นบวกแสดงว่ามี Wakeup
 Dijkstra ยังได้ เสนอปฏิบต ั ิการ Down และ Up
 Down จะตรวจสอบค่าตัวแปร ถ้ ามากกว่า 0 จะลดค่าแล้ ว
ดำเนินการต่อไป ถ้ าเป็ น 0 โปรเซสจะ sleep ตัวเอง โดยไม่

จำเป็ นต้ องให้ ปฏิบตั ิการ Down เสร็จสมบูรณ์ก่อน
ั ก
งพืน้น
ิ โคร
โคร
 Semaphore
 การตรวจสอบเป็ นขันตอนเดี
้ ยวเรี ยกว่า indivisible
atomatic action
 ปฏิบต ั ิการของ Semaphore เป็ นปฏิบตั ิการเดียวที่ทำให้
โปรเซสอื่นไม่สามารถแอ็กเซส Semaphore ได้ จนกว่าจะ
เสร็ จสมบูรณ์หรื อถูกบล็อก ทำให้ ชว่ ยแก้ ปัญหาการ ซิ
นโครไนซ์ และหลีกเลี่ยงการเกิด Race Condition
ั ก
งพืน้น
ิ โคร
โคร
 Semaphore
 ปฏิบต ั ิการ Up จะเพิ่มค่าของแอ็ดเดรส Semaphore
 ถ้ ามีโปรเซส sleep บน Semaphore นัน ้ ปฏิบตั ิการ Down จะไม่
สามารถเสร็จสิ ้นได้
 ระบบจะปิ ดบางตัว และทำให้ เสร็ จสิ ้นได้ ทำให้ เกิดปฏิบตั ิการ Up บน
Semaphore
 ทำให้ เพิ่มค่า Semaphore ขึ ้นอีก 1 ทำให้ Wakeup ได้
 ส่วน Down ในระหว่างปฏิบต ั ิการทังสอง

้ จะไม่เกิดอินเทอร์ รัพต์เลย
นอกจากจะใช้ Disable interrupt
ั ก
งพืน้น
ิ โคร
โคร
 Semaphore
 Semaphore มี 2 ชนิดคือ Binary Semaphore ที่มี 2 ค่าคือ
0 และ 1 เช่น mutex ที่ทำหน้ าที่ควบคุมการเช้ า CR หรื อ
ทำให้ เกิด Mutual Exclusion
 Counting Semaphore เป็ น Semaphore ตัวนับ ทำหน้ าที่
ประสานจังหวะการทำงานระหว่าง Producer และ

Consumer ที่มี Full เป็ นตัวนับจำนวนช่องข้ อมูล และ
Empty เป็ นตัวนับจำนวนช่องว่าง
ั ก
งพืน
ิ โคร
โคร
ไนซ์ ์
ไนซ
 Event Counter
 เป็ นตัวแปร integer ที่นบั เหตุการณ์ที่เกิดขึ ้น
 มีปฏิบต ั ิการ 3 ปฏิบตั ิการคือ Read, Advance และ Await
 มี &in เป็ นตัวแปรที่นบ ั จำนวนครัง้ ที่ใส่ข้อมูลในบัฟเฟอร์
และมี &out เป็ นตัวแปรที่นบั จำนวนครัง้ ที่นำข้ อมูลออกจาก
บัฟเฟอร์
 Sequence ใน Producer เป็ นตัวนับจำนวนชิ ้นที่ผลิต
 Sequence ใน Consumer เป็ นตัวนับจำนวนชิ ้นที่ถก ู นำไป
ั ก
งพืน้น
ิ โคร
โคร
 Mutex
 เป็ น Semaphore อย่างง่ายที่ใช้ จด ั การ Mutual Exclusion กับ
รี ซอร์ สที่แชร์
 มีสภาวะ unlocked (ใช้ 0) และ Locked (ใช้ เลขอื่น)
 เมื่อโปรเซสต้ องการเข้ า CR จะเรี ยก mutex_lock ถ้ า Mutex อยูใ่ น
สภาวะ unlocked การเรี ยกจะสำเร็จ โปรเซสที่เรี ยกจะเข้ า CR ได้

 ถ้ า Mutex นัน ้ Locked อยูแ่ ล้ ว โปรเซสจะถูกบล็อกจนกว่าโปรเซส
ใน CR นันเสร็้ จสิ ้น และเรี ยก mutex_unlocked
ั ก
งพืน้น
ิ โคร
โคร
 Mutex
 ถ้ ามีการบล็อกจากหลายโปรเซสพร้ อมกัน จะมีการสุม่ เลือก
โปรเซสเข้ า CR
 mutex_locked ต่างจาก enter_region ตรงที่ enter_region
ถ้ าเข้ า CR ไม่ได้ จะ busy waiting และรอเรื่ อยไป ส่วน

mutex_locked จะไม่มีการหยุด แต่จะมีการเรี ยก
thread_yield เพื่อให้ ซีพียเู ลือก thread ใหม่เข้ ามา
ั ก
งพืน้น
ิ โคร
โคร
 Monitor
 ปฏิบต ั ิการ Down 2 ปฏิบตั ิการในโค้ ดของ Producer ที่เรี ยงย้ อนกลับ
 Mutex จะลดค่าก่อน empty แทนที่จะลดค่าภายหลัง
 ถ้ าบัฟเฟอร์ เต็มแล้ ว Producer จะถูกบล็อก โดย Mutex จะให้ คา ่ เป็ น

0
 ถ้ า Consumer พยายามแอ็กเซสบัฟเฟอร์ ด้วยปฏิบต ั ิการ Down กับ
Mutex ซึง่ เป็ น 0 อยูแ่ ล้ ว จะถูกบล็อกอีก
 โปรเซสทังสองจะถู
้ กบล้ อกตลอดไป ทำอะไรไม่ได้ เลย
ั ก
งพืน้น
ิ โคร
โคร
 Monitor
 สภาวะเช่นนี ้เรี ยกว่า “Deadlock”
 การป้องกันข้ อผิดพลาดทำให้ มีการเสนอแนวทางการเขียน
โปรแกรมที่ถกู ต้ องสำหรับการซินโครไนซ์ เรี ยกว่า “Monitor”

 Monitor ก็คือชุดของโปรซีเดอร์ , ตัวแปร และโครงสร้ าง
ข้ อมูลที่รวมกันเป็ นแพ็คเกจเพื่อช่วยควบคุมการซินโครไนซ์
ในการจัดการ Mutual Exclusion กับรี ซอร์ สที่ใช้ ร่วมกัน
ั ก
ปป
ั ั ญหาการทำงานของโปรเซส
ญหาการทำงานของโปรเซส
 The Dining Philosophers Problem (โต๊ ะอาหารสำหรับการแก้ ไขปั ญหา)
ั ก
ปป
 The Dining Philosophers Problem
 นักปราชญ์ 5 ท่านนัง่ ทานอาหารรอบโต๊ ะกลม
 นักปราชญ์ แต่ละท่านต้ องใช้ ตะเกียบทัง้ 2 ข้ างซ้ าย-ขวา
 เมื่อทานเสร็ จในแต่ละรอบจะต้ องวางตะเกียบเพื่อให้ นก ั ปราชญ์

ท่านอื่นได้ ทานบ้ าง
 ถ้ านักปราชญ์ หยิบตะเกียบคนละข้ างพร้ อมกันจะเกิด ๆDeadlock
 ถ้ านักปราชญ์ ซ้าย-ขวาสลับกันทาน คนกลางจะไม่ได้ ทาน เรี ยกว่า
เกิด “Starvation”
ั ก
ปป
 The Dining Philosophers Problem
 เพื่อป้องกันปั ญหาจะใช้ binary semaphore ก่อนหยิบตะเกียบจะใช้
ปฏิบตั ิการ Down ของ Mutex ในขณะที่ต้องการเปลี่ยนตะเกียบจะใช้

ปฏิบตั ิการ Up
 ข้ อจำกัดอยูท่ ี่การกำหนดจำนวนนักปราชญ์ที่ทานพร้ อมกัน (ถ้ า 1
ท่านจะใช้ think, ถ้ ามากกว่านันจะใช้
้ อาร์ เรย์ state เก็บสถานะของ
นักปราชญ์วา่ ท่านใดกำลังทาน, คิด หรื อหิว)
 นักปราชญ์ ด้านข้ างจะแทนด้ วยมาโคร Left, Right ถ้ า I=2 แล้ ว
Left=1 และ Right=3
ั ก
ปป
 The Readers-Writers Problem
 มี 2 โปรเซสที่ทำงานร่วมกันคือโปรเซสอ่านข้ อมูล และ
โปรเซสเขียนข้ อมูล
 การอ่านและการเขียนสามารถมีได้ หลายโปรเซสพร้ อมกัน
 โปรเซสการอ่านสามารถทำได้ ครัง้ ละหลาย ๆ โปรเซส ส่วน
การเขียนจะกระทำได้ เพียงโปรเซสเดียวในเวลานัน้
 การใช้ Monitor หรื อการซินโครไนซ์อื่น ๆ ไม่สามารถจัดการ
Mutual Exclusion ได้
ั ก
ปป
 The Readers-Writers Problem
 ต้ องคำนึงการรอคอยด้ วย เพราะผู้อา่ นสามารถอ่านข้ อมูล
ได้ ตลอดเวลา ถ้ ามีผ้ อู า่ นเข้ ามาตลอดเวลา ผู้เขียนก็จะไม่
สามารถทำงานได้ หรื อถ้ าเราให้ สทิ ธิ์ผ้ เู ขียนมากกว่า ก็จะ
ทำให้ ผ้ อู า่ นไม่สามารถอ่านข้ อมูลได้
 การแก้ ปัญหาต้ องใช้ การจัดคิว ถ้ ามีผ้ เู ขียนอยูก ่ ่อนแล้ ว มีผ้ ู
อ่านเข้ ามาก็ต้องรอก่อน จะทำให้ ทงผู ั ้ ้ อา่ นและผู้เขียนไม่ต้อง
รอนาน
ั ก
ปป
 The Sleeping Barber Problem
 มีชา่ งตัดผม 1 คน, โต๊ ะตัดผม 1 ตัว และเก้ าอี ้รออีกจำนวนหนึง่
 ถ้ าไม่มีลกู ค้ าช่างตัดผมจะนอนพักผ่อน
 เมื่อลูกค้ าคนแรกเข้ ามาก็นงั่ บนโต๊ ะตัดผม
 ถ้ าระหว่างนันเข้ ้ ามาเพิ่มอีก
 นัง่ รอ (ถ้ ามีเก้ าอี ้ว่าง)
 กลับออกไป (ถ้ าไม่มีเก้ าอี ้ว่าง)
 ปั ญหาอยูท ่ ี่การทำให้ ชา่ งและลูกค้ าไม่เกิด Race Condition
ั ก
Thread
Thread
 Thread เป็ นส่วนย่อยของโปรเซสที่เรี ยกว่า “Lightweight
Process”
 ก็คือแต่ละโปรเซสมีหลาย Thread นัน ่ เอง
ั ก
Thread
Thread
ั ก
Thread
Thread
 ส่วนประกอบของ Thread
 หมายเลข Thread
 ตัวนับ : ติดตามให้ ทราบคำสัง่ ต่อไปที่จะเอ็กซิคิวต์
 ชุดของรี จิสเตอร์ : เก็บค่าตัวแปรที่ทำงานอยู่
 สแต็ก : เก็บประวัติการเอ็กซิคิวต์
ั ก
Thread
Thread
 ภายในโปรเซสที่ประกอบด้ วย Thread จะมีการแชร์ รีซอร์ ส
 ถ้ า 1 โปรเซสควบคุม 1 Thread จะเรี ยกว่า “Single-
threaded” แต่ถ้า 1 โปรเซสควบคุมหลาย thread จะเรี ยก

ว่า “Multithreaded”
 โปรแกรมสมัยใหม่เช่น เว็บบราวเซอร์ มี thread กำลัง
แสดงรูปภาพ ในขณะที่อีก thread หนึง่ กำลังโหลดข้ อมูล

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

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

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

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

Os Ch02 Process

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Os Ch02 Process

Enviado por

Direitos autorais:

Formatos disponíveis

บทที่ 2

โปรเซส และ Thread

ปญหา : หากมีโปรเซสใดตองใชเวลานาน ๆ จะทำใหโปรเซ

การบล็อกโปรเซสเมือ ่ ต ้องการใช ้ I/O หรือมีการ

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

เป็ นส่วนย่อย ๆ แล้ วเอ็กซิคิวต์ขนานกันไป

FIFO (First In First Out)

ข้ อมูลออก FILO (First In Last Out)

 โปรเซสที่มีความเกี่ยวข้ องกันเรี ยกว่า Synchronous

 การซินโครไนซ์โปรเซสหรื อการเข้ าจังหวะของโปรเซส หมายถึง

การทำงานของโปรเซส 2 โปรเซสที่มีความเกี่ยวข้ องกัน เนื่องจาก

โปรเซส A ทำงานก่อนโปรเซส B โปรเซส B ทำงานก่อนโปรเซส A

โปรเซส A และโปรเซส B ทำงานพร้ อมกัน

 ใช้ คำสัง่ Able Interrupt ไว้ ตอนท้ ายก่อนออกจาก CR

 ข้ อเสียของวิธี Disable Interrupt

 คำสัง่ Disable Interrupt มีผลเฉพาะในระบบซีพียต ู วั เดียว ในกรณี

 กำหนดตัวแปรเพื่อเก็บสภาวะว่ามีโปรเซสอยูใ่ น CR หรื อไม่ โดย 0

แสดงว่าไม่มีโปรเซสอยู่ ส่วน 1 แสดงว่ามีโปรเซสอยู่

สองมาถึง while โปรเซส 0 จะเอ็กซิคิวต์ 0 ครัง้ และเข้ า CR

สามารถใช้ หน่วยความจำตรงนันได้ ้ จนกว่าคำสัง่ จะเสร็ จสิ ้น

เพื่อจะใช้ คำสัง่ TSL แล้ วทำการอ่านหรื อเขียนหน่วยความ

พารามิเตอร์ และแอ็ดเดรสของหน่วยความจำที่สมั พันธ์กนั

 Producer จะทำหน้ าที่ผลิตข้ อมูลแล้ วนำไปเก็บไว้ ในบัฟเฟอร์

ชิ ้น) และจะหยุดเมื่อบัฟเฟอร์ วา่ ง

Consumer นำข้ อมูลไปใช้ เมื่อมีข้อมูลอย่างน้ อย 1 ชุดในบัฟเฟอร์

 Wakeup จะเป็ นการเปลี่ยนสถานะจาก Blocked --> Ready

 ก่อนที่ Producer จะผลิต จะตรวจสอบว่า count=N หรื อไม่ ถ้ าเป็ น

N ก็จะ sleep ตัวเอง แต่ถ้ายังน้ อยกว่า N จะผลิตเพิ่มลงในบัฟเฟอร์

ถ้ าเป็ น 0 ก็จะ sleep ตัวเอง ถ้ าไม่ใช่ 0 ก็จะนำข้ อมูลไปใช้ แล้ วลด

ดำเนินการต่อไป ถ้ าเป็ น 0 โปรเซสจะ sleep ตัวเอง โดยไม่

 ส่วน Down ในระหว่างปฏิบต ั ิการทังสอง

ประสานจังหวะการทำงานระหว่าง Producer และ

 เมื่อโปรเซสต้ องการเข้ า CR จะเรี ยก mutex_lock ถ้ า Mutex อยูใ่ น

สภาวะ unlocked การเรี ยกจะสำเร็จ โปรเซสที่เรี ยกจะเข้ า CR ได้

ถ้ าเข้ า CR ไม่ได้ จะ busy waiting และรอเรื่ อยไป ส่วน

 ถ้ าบัฟเฟอร์ เต็มแล้ ว Producer จะถูกบล็อก โดย Mutex จะให้ คา ่ เป็ น

โปรแกรมที่ถกู ต้ องสำหรับการซินโครไนซ์ เรี ยกว่า “Monitor”

 เมื่อทานเสร็ จในแต่ละรอบจะต้ องวางตะเกียบเพื่อให้ นก ั ปราชญ์

ปฏิบตั ิการ Down ของ Mutex ในขณะที่ต้องการเปลี่ยนตะเกียบจะใช้

Left=1 และ Right=3

Mutual Exclusion ได้

 กลับออกไป (ถ้ าไม่มีเก้ าอี ้ว่าง)

 ปั ญหาอยูท ่ ี่การทำให้ ชา่ งและลูกค้ าไม่เกิด Race Condition

threaded” แต่ถ้า 1 โปรเซสควบคุมหลาย thread จะเรี ยก

แสดงรูปภาพ ในขณะที่อีก thread หนึง่ กำลังโหลดข้ อมูล

User thread ทำงานได้ พร้ อมกันดี

เพื่อนำ thread อื่นขึ ้นมารันแทน

 thread ที่ถก ู ยกเก เรี ยกว่า target thread

 Asynchronous : thread อื่นสัง่ ให้ target thread หยุดทันที

 Deferred : target thread ตรวจสอบตัวเองว่าตนเองจะถูก

ยกเลิกหรื อไม่ ถ้ าต้ องยกเลิก จะยกเลิกด้ วยตัวเอง

Você também pode gostar