DEADLOCKS Advanced Operating System Operating System Technology วงจรอับ DEADLOCKS

Deadlock Examples: Traffic Jam : Dining Philosophers Device allocation process 1 requests tape drive 1 & gets it process 2 requests tape drive 2 & gets it process 1 requests tape drive 2 but is blocked process 2 requests tape drive 1 but is blocked Semaphores : P(s) P(t) P(t) P(s) Operating Systems: Deadlock

Deadlocks สภาวะที่กระบวนการบางตัวหรือทุกตัว ไม่สามารถทำงาน ต่อไปได้ ส่วนใหญ่เกิดจากการรอคอยทรัพยากรในกลุ่มเดียวกัน ทรัพยากรในระบบ เวลาของ CPU (CPU time) Address Space File I/O

System Model เมื่อกระบวนการต้องการใช้ทรัพยากรของระบบ จะต้องทำตามลำดับขั้นตอนต่าง ๆ ดังนี้ การร้องขอ (Request) การใช้งาน (Use) การคืน (Release)

System Model การร้องขอและการคืนทรัพยากร คือ คำสั่งเรียกระบบ (System calls) ระบบจะตรวจสอบการร้องขอและจัดสรรทรัพยากรของกระบวนการโดยมีตารางที่ใช้บันทึก กลุ่มของกระบวนการจะตกอยู่ในสถานะวงจรอับ เมื่อทุก ๆ กระบวนการ ที่อยู่ในกลุ่มนั้น ต่างก็กำลังรอคอยที่จะใช้ทรัพยากรที่กำลังถูกใช้ โดยกระบวนการอื่นในกลุ่มนั้น

System Model ถ้าระบบจัดสรรทรัพยากรชนิดนั้นๆตัวใดก็ได้ แสดงว่า ทรัพยากรเหล่านั้นเป็นชนิดเดียวกัน (ใช้แทนกันได้) แต่ถ้าระบบจัดสรรทรัพยากรเฉพาะที่ระบุ แสดงว่า ทรัพยากรเหล่านั้นเป็นคนละชนิด (ใช้แทนกันไม่ได้หรือไม่เหมือนกัน)

ตัวอย่างสถานะวงจรอับ วงจรอับที่เกิดจากการที่กระบวนการพยายามที่จะแย่งกันใช้ทรัพยากรประเภทเดียวกัน สมมติ ระบบที่ประกอบไปด้วยเครื่องพิมพ์ 3 เครื่อง มีกระบวนการอยู่ 3 กระบวนการ และแต่ละกระบวนการกำลังใช้เครื่องพิมพ์อยู่กระบวนการละ 1 เครื่อง ต่อมามีการร้องขอเครื่องพิมพ์เพิ่มอีกกระบวนการละ 1 เครื่อง ทั้ง 3 กระบวนการ จะติดอยู่ในวงจรอับทันที แต่ละกระบวนการกำลังรอสถานการณ์ที่ “เครื่องพิมพ์ถูกปล่อยคืนสู่ระบบ” ซึ่งเป็นสถานการณ์ที่ขึ้นกับกระบวนการอื่นในวงจร (ที่กำลังรอคอยทรัพยากรอยู่เช่นกัน)

ลักษณะของวงจรอับ (Deadlock Characterization) เงื่อนไขในการติดวงจรอับ (Necessary Conditions) ทรัพยากรเป็นแบบใช้ร่วมกันไม่ได้ (Mutual exclusion) มีทรัพยากรอย่างน้อย 1 ตัว จัดอยู่ในกลุ่มทรัพยากรที่ใช้ร่วมกันไม่ได้ นั่นคือ จะมีเพียง 1 กระบวนการเท่านั้นที่จะใช้ทรัพยากรตัวนั้นได้ ถ้ามีกระบวนการอื่นร้องขอทรัพยากรที่กำลังถูกใช้อยู่ กระบวนการนั้นจะต้องรอ จนกระทั่งทรัพยากรนั้น ถูกคืนกลับสู่ระบบแล้ว

ลักษณะของวงจรอับ (Deadlock Characterization) เงื่อนไขในการติดวงจรอับ (Necessary Conditions) การถือครองแล้วรอคอย (Hold and Wait) มีอย่างน้อยหนึ่งกระบวนการ ที่กำลังถือครองทรัพยากรอยู่อย่างน้อย 1 ตัว และขณะเดียวกันก็กำลังรอคอยทรัพยากรเพิ่มอีก แต่เป็นทรัพยากรที่กำลังถูกถือครองโดยกระบวนการอื่นอยู่ ห้ามแทรกกลางคัน (No Preemption) เมื่อกระบวนการกำลังใช้ทรัพยากรอยู่ จะไม่มีการแทรกกลางคัน และจะถูกปล่อยคืนสู่ระบบ โดยความสมัครใจของกระบวนการนั้น (เมื่อกระบวนการนั้นได้ทำงานจนเสร็จสมบูรณ์แล้ว)

ลักษณะของวงจรอับ (Deadlock Characterization) เงื่อนไขในการติดวงจรอับ (Necessary Conditions) วงจรรอคอย (Circular Wait) เซตของกระบวนการ ที่กำลังรอคอยทรัพยากร (P0, P1, … , Pn) P0 กำลังรอคอยทรัพยากรที่ถือครองโดย P1 P1 กำลังรอคอยทรัพยากรที่ถือครองโดย P2 , … Pn-1 กำลังรอคอยทรัพยากรที่ถือครองโดย Pn และ Pn ก็กำลังรอคอยทรัพยากรที่ถือครองโดย P0

วงจรรอคอย (Circular Wait)

ลักษณะของวงจรอับ (Deadlock Characterization) เงื่อนไขในการติดวงจรอับ (Necessary Conditions) ต้องมีเงื่อนไขทั้ง 4 ข้อนี้ครบ จึงจะเกิดวงจรอับได้ เงื่อนไขทั้ง 4 ไม่ได้เป็นอิสระต่อกันอย่างแท้จริง เช่น วงจรรอคอย จะเกิดจากการที่มีเงื่อนไข การถือครองแล้วรอคอย ในระบบ

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) กราฟทางเดียว (direct graph)  กราฟการจัดสรรทรัพยากร(resource-allocation graph) เซตของ Node (V) Process (P) Resource (R) เซตของ Edge (E)

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) P = { P1, P2, … , Pn} เป็นเซตของกระบวนการทั้งหมดที่มีอยู่ในระบบ R = { R0, R1, … , Rn } เป็นเซตของทรัพยากรที่มีอยู่ในระบบ กระบวนการ Pi ร้องขอใช้ทรัพยากรไปยัง Rj (PiRj) เรียกว่า “เส้นร้องขอ” (Request Edge) ทรัพยากร Rj ถูกถือครองโดยกระบวนการ Pi (RjPi) เรียกว่า “เส้นถือครอง” (Assignment Edge)

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) แทนกระบวนการ แทนทรัพยากร  แทนจำนวนทรัพยากรแต่ละตัวซึ่งจะอยู่ภายในสี่เหลี่ยม เส้นร้องขอจะต้องชี้ไปยังกรอบสี่เหลี่ยม (ทรัพยากร; Rj) เท่านั้น เส้นถือครองจะต้องชี้ไปยังจุดใดจุดหนึ่งในสี่เหลี่ยม

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) Process Resource Type with 4 instances Pi requests instance of Rj Pi is holding an instance of Rj Pi Pi

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph)

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) กราฟการจัดสรรทรัพยากรในรูปข้างต้น แสดงสถานะของระบบ ดังนี้ เซต P = { P1, P2, P3 } เซต R = { R1, R2, R3, R4 } เซต E = { P1  R1, P2  R3, R1  P2, R2  P2, R2  P1, R3  P3 } ทรัพยากรในระบบ ทรัพยากรประเภท R1 = 1 ตัว ทรัพยากรประเภท R2 = 2 ตัว ทรัพยากรประเภท R3 = 1 ตัว ทรัพยากรประเภท R4 = 3 ตัว

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) สถานะของกระบวนการ กระบวนการ P1 กำลังถือครองทรัพยากรประเภท R2 และกำลังรอคอยที่จะใช้ทรัพยากรประเภท R1 กระบวนการ P2 กำลังถือครองทรัพยากรประเภท R1 และ R2 และกำลังรอคอยที่จะใช้ทรัพยากรประเภท R3 กระบวนการ P3 กำลังถือครองทรัพยากรประเภท R3 อยู่

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph)

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) ถ้าเป็นระบบที่ทรัพยากรแต่ละประเภทมีเพียง 1 ตัว เมื่อมีวงจรในกราฟ ก็จะต้องมีวงจรอับในระบบแน่นอน ถ้าทรัพยากรแต่ละประเภทมีจำนวนมากกว่า 1 ตัว วงจรที่เกิดขึ้นในกราฟ ไม่อาจเป็นตัวบอกได้เสมอไปว่า เกิดวงจรอับในระบบ สมมติว่ากระบวนการ P3 ได้ร้องขอทรัพยากรประเภท R2 แต่เนื่องจากไม่มีทรัพยากรตัวใด ในประเภท R2 ว่างเลย เส้นร้องขอ P3  R2 จึงถูกใส่เพิ่ม เข้าไปในกราฟ

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph)

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) ณ จุดนี้ จะเกิดวงจรอย่างน้อย 2 วง ขึ้นในระบบ คือ P1  R1  P2  R3  P3  R2  P1 P2  R3  P3  R2  P2

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) ทำให้เกิดวงจรอับกับกระบวนการ P1 , P2 และ P3 กระบวนการ P2 กำลังรอคอยทรัพยากรประเภท R3 ซึ่งถูกถือครอง โดยกระบวนการ P3 กระบวนการ P3 ก็กำลังร้องขอทรัพยากรประเภท R2 ซึ่งถูกถือครอง โดยกระบวนการ P1 และ P2 กระบวนการ P3 กำลังรอคอยให้ P1 หรือ P2 คืนทรัพยากรประเภท R2 กลับสู่ระบบ

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) จะเห็นว่ามี วงจร P1  R1  P3  R2  P1

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph) วงจรนี้จะไม่ก่อให้เกิดวงจรอับ ถ้ากระบวนการ P4 จะปล่อยทรัพยากร R2 ที่ตนเองถือครองอยู่เมื่อใช้เสร็จ ทรัพยากร R2 ถูกปล่อยกลับสู่ระบบ ระบบจะจัดทรัพยากร R2 ให้แก่กระบวนการ P3 ได้ วงจรก็จะขาดทันที สรุปได้ว่า ถ้าไม่มีวงจรในกราฟการจัดสรรทรัพยากรแล้ว ระบบจะไม่อยู่ในสถานะวงจรอับ ถ้ามีวงจรในกราฟ ระบบอาจจะเกิดวงจรอับหรือไม่เกิดก็ได้ กรณีทรัพยากรแต่ละประเภทมีมากกว่า 1 ตัว

การจัดการปัญหาวงจรอับ (Methods for Handing Deadlocks) การจัดการปัญหาวงจรอับมีอยู่ 3 วิธีหลัก ๆ คือ กำหนดกฎเกณฑ์บางอย่างในการใช้ทรัพยากร ไม่ต้องป้องกันใด ๆ เลย ปล่อยให้ระบบเกิดวงจรอับขึ้นก่อน แล้วค่อยตามแก้ไขทีหลัง มองข้ามปัญหาทั้งหมด แล้วทำว่าวงจรอับไม่เคยเกิดขึ้นในระบบ ถูกใช้ในระบบปฏิบัติการส่วนใหญ่ รวมทั้ง UNIX ด้วย

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) ป้องกันเงื่อนไขการเกิดวงจรอับ 4 ประการ Mutual exclusion Hold and wait No preemption Circular wait ป้องกันเพียงข้อใดข้อหนึ่ง ก็สามารถป้องกันวงจรอับไม่ให้เกิดขึ้นได้

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) ห้ามใช้ทรัพยากรร่วมกัน (Mutual Exclusion) เงื่อนไขในข้อนี้ คือ ระบบ ไม่อนุญาตให้มีการใช้ทรัพยากรร่วมกัน เช่น เครื่องพิมพ์จะไม่สามารถ ให้กระบวนการหลาย ๆ กระบวนการใช้พร้อมๆ กันได้ แต่ถ้าเรายอมให้ในระบบมีการใช้ทรัพยากรร่วมกันได้ ปัญหาวงจรอับก็จะไม่เกิด เช่น แฟ้มข้อมูลที่อ่านได้อย่างเดียวสามารถใช้ร่วมกันได้ ไม่สามารถทำได้เสมอไป เพราะยังมีทรัพยากรบางประเภท ที่ไม่มีทางใช้ร่วมกันได้

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) การถือครองแล้วรอคอย (Hold and Wait) คือ การที่จะไม่ให้เกิด “การถือครองแล้วรอคอย” ขึ้นในระบบ จะต้องกำหนดว่า เมื่อกระบวนการหนึ่งจะร้องขอทรัพยากร กระบวนการนั้นจะต้องไม่ได้ถือครองทรัพยากรใด ๆ อยู่ในขณะนั้น ซึ่งอาจทำได้ 2 วิธีการ คือ ให้กระบวนการร้องขอทรัพยากรที่ต้องการใช้ทั้งหมด (ตลอดการทำงาน) ก่อนที่จะเริ่มต้นทำงาน ยอมให้กระบวนการร้องขอทรัพยากรได้ ก็ต่อเมื่อกระบวนการนั้นมิได้ถือครองทรัพยากรใดไว้เลย

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) พิจารณาจากตัวอย่าง กระบวนการหนึ่งต้องการ คัดลอกข้อมูลจากเทปลงไปเก็บที่แฟ้มข้อมูลในดิสก์ เรียงลำดับข้อมูลของแฟ้มข้อมูลในดิสก์ พิมพ์ผลลัพธ์ออกสู่เครื่องพิมพ์  (วิธีแรก) ร้องขอทรัพยากรที่ต้องการใช้ทั้งหมด แสดงว่ากระบวนการนี้ ก็จะถือครองเครื่องพิมพ์ไว้ตลอดเวลาที่กระบวนการทำงานอยู่ ถึงแม้ว่ากระบวนการนี้ จะใช้เครื่องพิมพ์เฉพาะในตอนท้ายของการทำงานเท่านั้น

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) (วิธีที่ 2) ให้กระบวนการร้องขอทรัพยากรในตอนเริ่มต้น แค่เทป และแฟ้มข้อมูลในดิสก์ โดยเมื่อได้รับทรัพยากรแล้ว กระบวนการจะคัดลอกข้อมูลและคืนทรัพยากรกลับสู่ระบบ จากนั้นร้องขอแฟ้มข้อมูลในดิสก์และเครื่องพิมพ์ใหม่อีกครั้งหนึ่ง เมื่อพิมพ์เสร็จเรียบร้อยแล้วก็จะคืนทรัพยากรกลับสู่ระบบ เป็นอันสิ้นสุดการทำงานของกระบวนการ

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) วิธีการแรก มีข้อเสียคือ การใช้ทรัพยากรจะมีประสิทธิผลต่ำมาก ปัญหาการแช่เย็น (starvation) คือ บางกระบวนการต้องการใช้ทรัพยากร (ที่นิยมใช้กันมาก) หลาย ๆ ตัว อาจต้องรอคอย อย่างไม่มีที่สิ้นสุด วิธีการสอง มีข้อเสียคือ เสียเวลาที่ต้องคืนทรัพยากรที่ถือครองอยู่ เพื่อที่จะร้องขอกลับมาใหม่อีกร่วมกับทรัพยากรตัวใหม่

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) ห้ามแทรกกลางคัน (No Preemption) กำหนดกฎเกณฑ์ดังนี้ ถ้ากระบวนการหนึ่งที่กำลังถือครองทรัพยากรบางส่วนอยู่ ร้องขอทรัพยากรเพิ่ม ระบบยังไม่สามารถจัดให้ได้ในทันที (แสดงว่ากระบวนการที่ร้องขอจะต้องรอ) เราจะให้ทรัพยากรทั้งหมดที่กระบวนการนี้ถือครองอยู่ ถูกแทรกกลางคัน นั่นคือ ทรัพยากรที่ถือครองอยู่ทั้งหมดจะถูกปล่อยคืนสู่ระบบ กระบวนการที่ถูกแทรกกลางคันนี้จะต้องรอคอยทรัพยากร ทั้งที่ร้องขอไว้ตั้งแต่แรกและที่ถูกแทรกกลางคันก่อนที่จะสามารถทำงานต่อไปได้

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) วิธีการนี้มักใช้กับทรัพยากรที่สามารถเก็บค่าสถานะและติดตั้งค่ากลับคืนมาได้ง่าย ค่าในรีจีสเตอร์ (ของหน่วยประมวลผลกลาง) เนื้อที่ในหน่วยความจำหลัก ไม่สามารถใช้กับทรัพยากรทั่ว ๆ ไป เช่น เครื่องพิมพ์และเทป เป็นต้น

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) วงจรรอคอย (Circular Wait) ซึ่งสามารถทำได้โดย การกำหนดลำดับของทรัพยากรทั้งหมดในระบบ กระบวนการต้องร้องขอใช้ทรัพยากร เรียงตามเลขลำดับนี้ R = { R1 , R2, … , Rm } ; R เป็นเซตของทรัพยากรในระบบ ทรัพยากรแต่ละประเภทมีค่าเลขลำดับเป็นเลขจำนวนเต็มที่ไม่ซ้ำกัน เขียนแทนด้วย F(Ri) สามารถเปรียบเทียบทรัพยากร 2 ประเภทได้ว่าตัวใดมีลำดับก่อน-หลัง

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) ตัวอย่างเช่น ถ้าเซตของ R ประกอบด้วย เทป ดิสก์ เครื่องพิมพ์ ค่าเลขลำดับ F(Ri) กำหนดได้ดังนี้ F (เทป) = 1 F (ดิสก์) = 5 F (เครื่องพิมพ์) = 12 กำหนดวิธีการในการร้องขอทรัพยากรในระบบดังนี้ เริ่มต้นกระบวนการอาจร้องขอทรัพยากรใด ๆ ก็ได้ ต่อจากนั้นกระบวนการแต่ละตัวสามารถร้องขอทรัพยากรได้ในลำดับที่เพิ่มขึ้นเท่านั้น F(Rj) > F(Ri) ถ้าเป็นการร้องขอทรัพยากรประเภทเดียวกันหลาย ๆ ตัว กระบวนการจะต้องร้องขอทรัพยากรทีละตัว

การป้องกันการเกิดวงจรอับ (Deadlock Prevention) ในทางตรงกันข้าม ถ้ากระบวนการต้องการร้องขอทรัพยากรประเภท Rj กระบวนการจะต้องปล่อยทรัพยากร Ri คืนสู่ระบบก่อน เช่นถือครอง R5 อยู่อยากได้ R1 ต้องคืน R5 ก่อน ; R5  R1 การกำหนดค่าเลขลำดับของทรัพยากร ควรเรียงตามลำดับการใช้งานตามปกติในระบบ เช่น ปกติเรามักใช้เทปก่อนเครื่องพิมพ์เสมอ จึงควรกำหนดลำดับให้ F(เทป) < F (เครื่องพิมพ์)

Deadlock Example /* thread one runs in this function */ void *do_work_one(void *param) { pthread_mutex_lock(&first_mutex); pthread_mutex_lock(&second_mutex); /** * Do some work */ pthread_mutex_unlock(&second_mutex); pthread_mutex_unlock(&first_mutex); pthread_exit(0); } /* thread two runs in this function */ void *do_work_two(void *param) { /** * Do some work */ pthread_mutex_unlock(&first_mutex); pthread_mutex_unlock(&second_mutex);

Deadlock Example with Lock Ordering void transaction(Account from, Account to, double amount) { mutex lock1, lock2; lock1 = get_lock(from); lock2 = get_lock(to); acquire(lock1); acquire(lock2); withdraw(from, amount); deposit(to, amount); release(lock2); release(lock1); } Transactions 1 and 2 execute concurrently. Transaction 1 transfers $25 from account A to account B, and Transaction 2 transfers $50 from account B to account A

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) ต้องมีข้อมูลการร้องขอทรัพยากรในระบบโดยรวม กระบวนการต้องประกาศทรัพยากรสูงสุดแต่ละประเภทที่ต้องการ ตรวจดูสถานะของการจัดสรรทรัพยากรของระบบ ทรัพยากรทั้งหมด จำนวนทรัพยากรที่ถูกจัดสรรให้กระบวนการ ความต้องการสูงสุดของกระบวนการ ระบบจะอยู่สถานะปลอดภัยถ้ากระบวนการเสร็จโดยไม่เกิดวงจรอับ

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) สถานะปลอดภัย (Safe State) ระบบจะอยู่ในสถานะปลอดภัย (Safe State) ก็ต่อเมื่อมีลำดับการจัดสรรทรัพยากรอย่างปลอดภัยแก่กระบวนการ (Safe Sequence) ลำดับของกระบวนการ <P1, P2 , … , Pn> เป็นลำดับที่ปลอดภัย สำหรับสถานะของการจัดสรรทรัพยากรปัจจุบัน

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) ถ้าไม่สามารถหาลำดับกระบวนการที่ปลอดภัยในระบบได้ แสดงว่าระบบอยู่ในสถานะไม่ปลอดภัย (unsafe state) สถานะปลอดภัยเป็นสถานะที่ไม่มีวงจรอับ สถานะไม่ปลอดภัยเป็นสถานะที่อาจเกิดวงจรอับได้ แต่ก็ไม่ได้หมายความว่า สถานะไม่ปลอดภัยทั้งหมดจะก่อให้เกิดวงจรอับเสมอไป

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) ตัวอย่าง - ระบบหนึ่งมีเทป 12 เครื่อง และมีกระบวนการ 3 กระบวนการอยู่ในระบบ คือ P0, P1 และ P2 กระบวนการ P0, P1 และ P2 ต้องการใช้เทปสูงสุด 10 , 4 และ 9 เครื่องตามลำดับ ถ้า ณ เวลา T0 กระบวนการ P0, P1 และ P2 ได้รับเทป กระบวนการละ 5 , 2 และ 2 เครื่องตามลำดับ (แสดงว่า ณ เวลานั้นมีเทปว่างอยู่ 3 เครื่อง)

ความต้องการปัจจุบัน (Current Needs) การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) กระบวนการ (Process) ความต้องการสูงสุด (Maximum Needs) ความต้องการปัจจุบัน (Current Needs) P0 P1 P2 10 4 9 5 2 ณ เวลา T0 ลำดับกระบวนการ < P1, P0 , P2 > แสดงว่า ระบบอยู่ในสถานะปลอดภัย

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) ระบบอาจจะเปลี่ยนจากสถานะปลอดภัยไปเป็นสถานะไม่ปลอดภัยได้ เช่น สมมติว่า ณ เวลา T1 กระบวนการ P2 ร้องขอเทปเพิ่มอีก 1 เครื่องและได้รับการจัดสรรจะทำให้สถานะของระบบกลายเป็นสถานะไม่ปลอดภัยทันที ทำให้ P1 ได้รับทรัพยากรและทำงานเสร็จเพียงกระบวนการเดียว โดยคืนกลับสู่ระบบเพียง 4 เครื่อง ซึ่งไม่เพียงพอต่อกระบวนการ P0 และ P2 ไม่สามารถหาลำดับของกระบวนการที่ปลอดภัยได้

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) โดยใช้แนวคิดของสถานะปลอดภัยนี้ เราสามารถสร้างขั้นตอนวิธีการหลีกเลี่ยงวงจรอับซึ่งจะประกันได้ว่า จะไม่เกิดวงจรอับขึ้นในระบบ เมื่อกระบวนการร้องขอทรัพยากรเพิ่มและทรัพยากรยังมีว่างพอ ระบบต้องตัดสินใจว่าจะให้ทรัพยากรตามที่ร้องขอทันทีหรือไม่ หรือ (ให้กระบวนการรอไปก่อน) พิจารณาว่าถ้าจัดสรรให้ตามที่ร้องขอแล้วระบบจะยังคงอยู่ในสถานะปลอดภัยหรือไม่

อัลกอริทึมของกราฟการจัดสรรทรัพยากร (Resource-Allocation Graph Algorithm) ใช้กราฟการจัดสรรทรัพยากร เพิ่มเส้นความต้องการ (Claim Edge) คือ ในอนาคตกระบวน Pi ร้องขอ Rj เขียนแทนด้วย Pi Rj เส้นความต้องการมีทิศทางเดียวกันกับเส้นร้องขอ เส้นความต้องการจะแสดงด้วยเส้นประ แต่เส้นร้องขอแสดงด้วยเส้นทึบ

อัลกอริทึมของกราฟการจัดสรรทรัพยากร (Resource-Allocation Graph Algorithm) สมมติว่ากระบวนการ Pi ได้ร้องขอทรัพยากรประเภท Rj ระบบจะอนุมัติการร้องขอนี้ ถ้าการเปลี่ยน PiRj ไปเป็น RjPi แล้ว ไม่ทำให้เกิดวงจรขึ้น กระบวนการนั้นจะต้องรอระบบมีทรัพยากรมากขึ้น เมื่อพบว่า เส้นถือครองที่เกิดใหม่ทำให้เกิดวงจร เส้นถือครองของกระบวนการที่ร้องขอจะไม่ก่อให้เกิดวงจร ถ้าไม่มีวงจรในกราฟ การอนุมัติทรัพยากรจะทำให้ระบบอยู่ในสถานะปลอดภัย ถ้าเกิดมีวงจรในกราฟแล้วการอนุมัติทรัพยากร จะทำให้ระบบอยู่ในสถานะไม่ปลอดภัย

อัลกอริทึมของกราฟการจัดสรรทรัพยากร (Resource-Allocation Graph Algorithm)

อัลกอริทึมของกราฟการจัดสรรทรัพยากร (Resource-Allocation Graph Algorithm) สมมติว่า P2 ร้องขอ R2 ระบบจะไม่อนุมัติถึงแม้ว่าทรัพยากร R2 จะว่างอยู่ก็ตาม ถ้าระบบอนุมัติ ; R2P2 จะก่อให้เกิดวงจรในกราฟ

อัลกอริทึมของกราฟการจัดสรรทรัพยากร (Resource-Allocation Graph Algorithm) ทำให้ระบบอยู่ในสถานะไม่ปลอดภัย โดยอาจเกิดวงจรอับขึ้นในระบบ ถ้ากระบวนการ P1 เกิดร้องขอ R2 กระบวนการ P2 ร้องขอ R1

อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) เมื่อมีกระบวนการใหม่เกิดขึ้นในระบบ กระบวนการนั้นจะต้องประกาศจำนวนทรัพยากรสูงสุดที่ต้องการในแต่ละประเภท จำนวนที่ต้องการนี้จะต้องไม่เกินกว่าจำนวนที่มีอยู่จริงในระบบ เมื่อร้องขอ ระบบจะต้องพิจารณาว่าเมื่อจัดสรรทรัพยากรให้แต่ละกระบวนการแล้ว จะทำให้ระบบอยู่ในสถานะปลอดภัยหรือไม่ ถ้าอยู่ ระบบก็จะจัดสรรทรัพยากรให้ตามที่ขอ ถ้าไม่อยู่ กระบวนการที่ร้องขอก็จะต้องรอจนกว่ากระบวนการอื่นได้คืนทรัพยากรบางส่วนให้แก่ระบบจนเพียงพอ

อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) ระบบต้องเก็บโครงสร้างข้อมูลหลายตัวเพื่อใช้ โครงสร้างข้อมูลเหล่านี้ เป็นตัวบอกสถานะของการจัดสรรทรัพยากรในระบบ กำหนดให้ n เป็นจำนวนกระบวนการในระบบ m เป็นจำนวนของประเภททรัพยากร

อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) โครงสร้างข้อมูลที่จำเป็นมีดังนี้ Available : เวคเตอร์ขนาด m ใช้เก็บค่าจำนวนทรัพยากรที่ว่างของทรัพยากรแต่ละประเภท Available[j] = k หมายถึง ทรัพยากรประเภท Rj มีจำนวนทรัพยากรว่างอยู่ k ตัว Max : เมทริกซ์ขนาด n x m ใช้เก็บค่าจำนวนสูงสุดของทรัพยากรแต่ละประเภทที่กระบวนการแต่ละตัวต้องการใช้ Max[i,j] = k หมายถึง กระบวนการ Pi ต้องการทรัพยากร Rj มากที่สุด k ตัว

อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) Allocation : เมทริกซ์ขนาด n x m ใช้เก็บค่าจำนวนทรัพยากร แต่ละประเภทที่กระบวนการแต่ละตัวกำลังถือครองอยู่ Allocation[i,j] = k หมายถึง กระบวนการ Pi กำลังถือครองทรัพยากรประเภท Rj อยู่ k ตัว Need : เมทริกซ์ขนาด n x m ใช้เก็บค่าจำนวนทรัพยากรแต่ละประเภทที่กระบวนการแต่ละตัวอาจร้องขอเพิ่มอีกได้ Need[i,j] = k หมายถึง กระบวนการ Pi อาจร้องขอทรัพยากรประเภท Rj ได้อีก k ตัว จะเห็นว่า Need [i,j] = Max[i,j] – Allocation[i,j]

ขั้นตอนวิธีตรวจดูสถานะปลอดภัย (Safety Algorithm) ขั้นตอนวิธีการตรวจสอบว่าระบบอยู่ในสถานะปลอดภัยหรือไม่ ดังนี้ กำหนดให้ Work และ Finish เป็นเวคเตอร์ขนาด m และ n ตามลำดับ

ขั้นตอนวิธีตรวจดูสถานะปลอดภัย (Safety Algorithm) 1. Initialize: Work = Available Finish [i] = false for i = 0, 1, …, n- 1 2. Find an i such that both: (a) Finish [i] = false (b) Needi  Work If no such i exists, go to step 4

ขั้นตอนวิธีตรวจดูสถานะปลอดภัย (Safety Algorithm) 3. Work = Work + Allocationi Finish[i] = true go to step 2 4. If Finish [i] == true for all i, then the system is in a safe state

อัลกอริทึมร้องขอทรัพยากร (Resource-Request Algorithm) Requesti เป็นเวคเตอร์ หมายถึง กระบวนการ Pi ได้ร้องขอทรัพยากรประเภท Rj เป็นจำนวน k ตัว เมื่อกระบวนการ Pi ร้องขอทรัพยากร ระบบจะจัดการ ดังนี้ ขั้นที่ 1 ถ้า Requesti > Needi ระบบจะแจ้งข้อผิดพลาดว่า “กระบวนการขอทรัพยากรมากกว่าที่ระบุ” กระบวนการจะถูกออกจากระบบ ถ้า Requesti  Needi จะไปทำงานในขั้นตอนที่ 2

อัลกอริทึมร้องขอทรัพยากร (Resource-Request Algorithm) ขั้นที่ 2 ถ้า Requesti > Available ให้ Pi รอจนกว่าทรัพยากรที่ร้องขอจะว่าง จากนั้นจึงไปทำงานในขั้นตอนที่ 3 ถ้า Requesti  Available จะไปทำงานในขั้นตอนที่ 3 ทันที

อัลกอริทึมร้องขอทรัพยากร (Resource-Request Algorithm) ขั้นที่ 3 ระบบจะสมมติว่าได้จัดสรรทรัพยากรให้ตามที่กระบวนการ Pi ร้องขอมา โดยระบบจะมีสถานะเปลี่ยนไปดังนี้ Available := Available – Requesti; Allocationi := Allocationi + Requesti; Needi := Needi – Requesti;

อัลกอริทึมร้องขอทรัพยากร (Resource-Request Algorithm) ตรวจสอบสถานะของการจัดสรรทรัพยากรขณะนี้เป็นสถานะปลอดภัยหรือไม่ ถ้าปลอดภัย ระบบก็จะจัดสรรทรัพยากรให้ตามที่สมมติทันที ถ้าไม่ ระบบก็จะให้กระบวนการ Pi รอ และถอยกลับไปอยู่ในสถานะเดิม (ก่อนการสมมติค่า Available , Allocationi และ Needi เป็นค่าเดิม)

ตัวอย่าง ระบบหนึ่งมีกระบวนการอยู่ 5 ตัว คือ P0, P1, P2, P3 และ P4 มีทรัพยากรอยู่ 3 ประเภท คือ A , B และ C แต่ละประเภทมีจำนวนทรัพยากร 10 , 5 และ 7 ตัว ตามลำดับ

ตัวอย่าง Allocation Max Available A B C P0 P1 P2 P3 P4 0 1 0 2 0 0 3 0 2 2 1 1 0 0 2 7 5 3 3 2 2 9 0 2 2 2 2 4 3 3 3 3 2

ตัวอย่าง เนื่องจากเมทริกซ์ Need เกิดจาก Max – Allocation ดังนั้นจะได้ว่า Need A B C P0 P1 P2 P3 P4 7 4 3 1 2 2 6 0 0 0 1 1 4 3 1

ตัวอย่าง เราพบว่า ระบบอยู่ในสถานะปลอดภัยเนื่องจากกระบวนการอาจทำงานได้ตามลำดับ <P1, P3, P4, P2, P0> สมมติว่า กระบวนการ P1 ร้องขอทรัพยากรประเภท A และ C เพิ่มอย่างละ 1 และ 2 ตัวตามลำดับ ดังนั้น Request1 = (1,0,2) ระบบจะตัดสินใจว่าจะอนุมัติทรัพยากรให้ ตามที่ร้องขอหรือไม่ตามขั้นตอนดังนี้ Request1  Need1 เนื่องจาก (1,0,2)  (1,2,2) Request1  Available เนื่องจาก (1,0,2)  (3,3,2)

ตัวอย่าง Available := Available – Requesti; เมื่อผ่าน 2 ขั้นแรกแล้ว ระบบจะมีสถานะเปลี่ยนไปดังนี้ Available := Available – Requesti; Allocationi := Allocationi + Requesti; Needi := Needi – Requesti;

ตัวอย่าง เมื่อผ่าน 2 ขั้นแรกแล้ว ระบบก็จะสมมติว่า ได้จัดสรรทรัพยากรให้ตามที่ร้องขอ ทำให้ระบบมีสถานะใหม่ดังนี้ Allocation Need Available A B C P0 P1 P2 P3 P4 0 1 0 3 0 2 2 1 1 0 0 2 7 4 3 0 2 0 6 0 0 0 1 1 4 3 1 2 3 0

ตัวอย่าง จากนั้นก็จะตรวจสอบว่าสถานะใหม่นี้จะเป็นสถานะปลอดภัยหรือไม่ โดยใช้ขั้นตอนวิธีสถานะปลอดภัย (safety algorithm) พบว่า กระบวนการอาจทำงานได้ ตามลำดับ <P1, P3, P4, P0, P2> ซึ่งเป็นไปตามเงื่อนไขของสถานะปลอดภัย เมื่อเป็นเช่นนี้ ระบบจะสามารถอนุมัติการร้องขอของ P1 ได้ ในบางกรณี ระบบอาจไม่อนุมัติการร้องขอของกระบวนการเพิ่ม แม้ว่าจะมีทรัพยากรพอ เพราะว่าเมื่อระบบลองสมมติว่าได้จัดสรรทรัพยากรให้ตามที่ขอแล้วพบว่าสถานะใหม่เป็นสถานะไม่ปลอดภัย

การตรวจหาวงจรอับ (Deadlock Detection) ถ้าในระบบปฏิบัติการไม่มีการป้องกันหรือหลีกเลี่ยงวงจรอับแล้ว ในที่สุดระบบก็อาจจะตกอยู่ในสถานะวงจรอับได้ ดังนั้นระบบจึงจำต้องมีวิธีอื่นทดแทน ขั้นตอนวิธีที่จะตรวจหาวงจรอับในระบบว่าเกิดขึ้นแล้วหรือยัง ขั้นตอนวิธีในการแก้ไขวงจรอับ

ระบบที่มีทรัพยากรแต่ละประเภทเพียงตัวเดียว (Single Instance of Each Resource Type) นำกราฟการจัดสรรทรัพยากรมาแปลงสภาพเล็กน้อยเป็นกราฟการรอคอยทรัพยากร (Wait-for-Graph) ทำโดยเอาสี่เหลี่ยมที่แทนทรัพยากรออก และยุบรวมลูกศรเข้าด้วยกัน ดังนี้ ถ้ามีลูกศรจาก Pi  Pj ในกราฟการรอคอยทรัพยากร แสดงว่า Pi กำลังรอทรัพยากรซึ่ง Pj ถือครองอยู่

ระบบที่มีทรัพยากรแต่ละประเภทเพียงตัวเดียว (Single Instance of Each Resource Type) (a) เป็นต้นแบบกราฟการจัดสรรทรัพยากร (b) แปลงเป็นกราฟการรอคอยทรัพยากร

ระบบที่มีทรัพยากรแต่ละประเภทเพียงตัวเดียว (Single Instance of Each Resource Type) ถ้าในกราฟการรอคอยทรัพยากรมีวงจรแล้วก็จะเกิดวงจรอับ ในทางกลับกัน ถ้าเกิดวงจรอับแล้ว ก็จะมีวงจรในกราฟการรอคอยทรัพยากร ระบบต้องเก็บข้อมูลของกราฟการรอคอยทรัพยากรไว้ และใช้ขั้นตอนวิธีการตรวจหาวงจรในกราฟ เพื่อตรวจหาวงจรอับในระบบ โดยคอยตรวจดูทุก ๆ ช่วงเวลา

ระบบที่มีทรัพยากรแต่ละประเภทหลายตัว (Several Instances of a Resource Type) ขั้นตอนวิธีในการตรวจหาวงจรอับนี้คล้ายกับ Banker’s Algorithm ซึ่งจำเป็นต้องใช้โครงสร้างข้อมูลดังต่อไปนี้ Available : เวคเตอร์ขนาด m แสดงจำนวนทรัพยากรแต่ละชนิด ที่ยังว่างอยู่ (ไม่ได้ถูกกระบวนการใดถือครองอยู่) Allocation : เมทริกซ์ n x m ใช้เก็บค่าจำนวนทรัพยากรแต่ละชนิดที่กระบวนการแต่ละตัวถือครองอยู่ Request : เมทริกซ์ n x m ใช้เก็บค่าจำนวนทรัพยากรแต่ละชนิดที่กระบวนการแต่ละตัวกำลังร้องขอ

ระบบที่มีทรัพยากรแต่ละประเภทหลายตัว (Several Instances of a Resource Type) ขั้นตอนวิธีตรวจหาวงจรอับ 1. Work := Available; 2. FOR i:= 1 TO n DO IF Allocationi 0 THEN Finish[i] := FALSE ELSE Finish[i] := TRUE;

ระบบที่มีทรัพยากรแต่ละประเภทหลายตัว (Several Instances of a Resource Type) WHILE i n DO BEGIN IF Finish[i] = FALSE AND Request[i]  Work THEN BEGIN Work := Work + Allocationi; Finish[i] := TRUE; i := i+1; END ELSE i := i+1; END;

ระบบที่มีทรัพยากรแต่ละประเภทหลายตัว (Several Instances of a Resource Type) 4. FOR i=1 TO n DO IF Finish[i] = FALSE THEN process Pi is in a deadlocked. 5. IF Finish[i] = TRUE ทั้งหมด แสดงว่าขณะนี้ระบบไม่เกิดวงจรอับ.

ตัวอย่าง ระบบมี 5 กระบวนการ P0 , P1 , P2 , P3 และ P4 มีทรัพยากรชนิด A 7 ตัว , ชนิด B 2 ตัว , ชนิด C 6 ตัว ณ เวลา T0 ระบบอยู่ในสถานะดังนี้ Allocation Request Available A B C P0 P1 P2 P3 P4 0 1 0 2 0 0 3 0 3 2 1 1 0 0 2 0 0 0 2 0 2 1 0 0

ตัวอย่าง สรุปได้ว่า ขณะนี้ไม่มีวงจรอับเกิดขึ้นหรือระบบไม่ได้อยู่ในสถานะวงจรอับ โดยการดำเนินตามขั้นตอนวิธีตรวจหาวงจรอับ (Deadlock Detection) พบว่ามีลำดับการทำงานหนึ่ง คือ <P0 , P2 , P3 , P1 , P4> ซึ่งจะให้ Finish [i] = TRUE ทั้งหมด

ตัวอย่าง สมมติว่ากระบวนการ P2 ร้องขอทรัพยากรประเภท C เพิ่มอีก 1 ตัว สถานะของระบบจะกลายเป็น พบว่ามีวงจรอับเกิดขึ้นในระบบ แม้ว่า P0 อาจทำงานเสร็จ แล้วคืนทรัพยากรชนิด Bสู่ระบบ กระบวนการอื่น ๆ ก็ไม่อาจทำงานต่อได้ เพราะทรัพยากรที่ว่างอยู่ ไม่พอตามคำร้องขอ ดังนั้นระบบจึงตกอยู่ในสถานะวงจรอับ โดยมีกระบวนการ P1 , P2 , P3 และ P4 อยู่ในวงจรอับ Request A B C P0 P1 P2 P3 P4 0 0 0 2 0 2 0 0 1 1 0 0 0 0 2

การใช้วิธีการตรวจหาวงจรอับ (Detection-Algorithm Usage) เราจะใช้วิธีการตรวจหาวงจรอับ เมื่อใดบ้าง ขึ้นอยู่กับ 2 ปัจจัย คือ 1. ความถี่ของการเกิดวงจรอับในระบบ 2. จำนวนกระบวนการที่ติดอยู่ในวงจรอับ วงจรอับจะเกิดขึ้นเมื่อมีเหตุการณ์ที่บางกระบวนการร้องขอทรัพยากรแล้วระบบไม่สามารถอนุมัติให้ได้ทันที เราจึงอาจตรวจหาวงจรอับโดยตรวจทุกครั้งที่เหตุการณ์นี้เกิดขึ้น การตรวจหาวงจรอับบ่อยเกินไป ย่อมทำให้เสียค่าใช้จ่าย(เวลา)มาก เพื่อที่จะประหยัดค่าใช้จ่าย เราอาจตรวจหาทุก ๆ ช่วงเวลาแทน

การแก้ไขวงจรอับ (Recovery from Deadlock) เมื่อตรวจพบว่าเกิดวงจรอับขึ้นในระบบแล้ว ระบบอาจจัดการได้ 2 วิธี คือ 1. รายงานให้ผู้ควบคุมทราบว่าขณะนี้เกิดวงจรอับขึ้นในระบบแล้ว และให้ผู้ควบคุมจัดการแก้ไขวงจรอับเอง 2. ระบบแก้ไขวงจรอับเองโดยอัตโนมัติ ยกเลิกกระบวนการที่ติดอยู่ในวงจรอับบางกระบวนการ อนุญาตให้มีการแทรกกลางคันทรัพยากรบางส่วนที่ติดอยู่ในวงจรอับได้

การยกเลิกกระบวนการ (Process Termination) การยกเลิกกระบวนการในวงจรอับ มีอยู่ 2 วิธี (เมื่อกระบวนการถูกยกเลิก ทรัพยากรที่กระบวนการถือครองอยู่จะคืนกลับสู่ระบบ) ยกเลิกกระบวนการทั้งหมดที่ติดอยู่ในวงจรอับ ค่าใช้จ่ายสูงแต่แก้ไขได้แน่นอน ยกเลิกกระบวนการในวงจรอับทีละกระบวนการ จนกระทั่งระบบกลับสู่สภาวะปกติ ค่าใช้จ่ายสูง ตรวจสอบสถานะวงจรอับใหม่

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

(Resource Preemption) การแทรกกลางคัน (Resource Preemption) ในการเลือกใช้วิธีการแทรกกลางคัน เราจะต้องพิจารณาผลที่จะเกิด 3 ข้อดังนี้ การเลือกผู้รับเคราะห์ (Selection a victim) โดยการเลือกว่ากระบวนการใดจะถูกแทรกกลางคันแล้ว จะเสียค่าใช้จ่ายน้อยที่สุด จำนวนทรัพยากรที่ถือครอง, ระยะเวลาที่ทำงานไปแล้ว การถอยกลับ (Rollback) ให้กระบวนการนั้นถอยกลับไปอยู่ในจุดที่ปลอดภัย และให้เริ่มทำงานใหม่อีกครั้งจากจุดนี้ ถอยกลับไปที่จุดเริ่มต้น ถอยกลับไปเท่าที่จำเป็นในการแก้ไข การแช่เย็น (Starvation) เช่น มีกระบวนการหนึ่งถูกแทรกกลางคันทรัพยากรที่กำลังใช้อยู่เสมอ ๆ

การจัดการปัญหาวงจรอับโดยวิธีผสมผสาน (Combined Approach to Deadlock Handling) จัดแบ่งกลุ่มทรัพยากรและเลือกวิธีที่เหมาะสม มีประสิทธิภาพสูงสุดสำหรับแต่ละกลุ่ม เราอาจพิสูจน์ได้ว่าระบบที่ใช้วิธีผสมผสานนี้จะไม่เกิดวงจรอับ ดังนี้คือ วงจรอับไม่อาจจะเกิดข้ามกลุ่มของทรัพยากรได้ เพราะเราใช้วิธีการจัดเรียงลำดับทรัพยากร ในแต่ละกลุ่มก็จะไม่เกิดวงจรอับเพราะเราได้เลือกวิธีจัดการที่กล่าวมาแล้ว ดังนั้นระบบโดยรวมจะไม่เกิดวงจรอับ

ตัวอย่าง สมมติว่าระบบของเราประกอบไปด้วยทรัพยากร 4 ประเภท คือ ทรัพยากรภายในของระบบ (Internal Resources) ทรัพยากรที่ระบบใช้เอง เช่น PCB (Process Control Block) หน่วยความจำหลัก (Main Memory) ผู้ใช้ระบบต้องใช้ อุปกรณ์ต่าง ๆ ในระบบ (Job Resources) หน่วยความจำสำรอง (Swappable space) พื้นที่ในการบันทึก (Backing Store) สำหรับสำรองแต่ละงาน

ตัวอย่าง จัดแบ่งกลุ่มของทรัพยากรเป็น 4 กลุ่ม ตามที่กล่าวมาและในแต่ละกลุ่มใช้วิธีจัดการดังนี้ ทรัพยากรภายในของระบบ ป้องกันโดยการจัดลำดับทรัพยากร เพราะกระบวนการที่ร้องขอเป็นกระบวนการภายในของระบบเอง หน่วยความจำหลัก ป้องกันโดยการให้มีการแทรกกลางคันได้ เพราะอาจย้ายงานออกจากหน่วยความจำหลักไปเก็บไว้ในหน่วยความจำสำรอง (Backing Store) เมื่อมีกระบวนการต้องการใช้หน่วยความจำเพิ่ม และหน่วยความจำเต็มแล้ว

ตัวอย่าง อุปกรณ์ต่าง ๆ ในระบบ ใช้วิธีการหลีกเลี่ยง เพราะข้อมูลเกี่ยวกับความต้องการสูงสุดของแต่ละงานอาจรู้ล่วงหน้าได้ เช่น จากบัตรควบคุมงาน (Job Control Card) กรณีที่ใช้บัตรเจาะรู (Punch cards) หน่วยความจำสำรอง ป้องกันโดย การจัดสรรล่วงหน้า เพราะจำนวนหน่วยความจำสำรองสูงสุดของแต่ละงาน มักจะถูกกำหนดไว้แล้ว