อัลกอริทึมการแยกซึ่งกันและกันของ 2 กระบวนการของ Peterson นั้นเป็นสาเหตุของกระบวนการที่กำลังจะตายหรือไม่?

9

ฉันคิดว่าในอัลกอริทึมของ Petersonสำหรับการยกเว้นซึ่งกันและกันหากกระบวนการก่อนเข้าสู่ส่วนที่สำคัญคือการตายหรือถูกยกเลิกกระบวนการอื่นจะวนซ้ำตลอดไปโดยรอที่จะเข้าสู่ส่วนที่สำคัญ

ในรูปภาพหากกระบวนการ 1 หยุดทำงานส่วนที่เหลือของกระบวนการหลังกระบวนการ 1 จะดำเนินการจนถึงตำแหน่งที่กระบวนการ 1 เป็น แต่วนรอบ

ป้อนคำอธิบายรูปภาพที่นี่

จะเกิดอะไรขึ้นถ้ากระบวนการที่มาถึงส่วนที่สำคัญเสียชีวิตก่อนที่จะออกไป

programming-languages concurrency mutual-exclusion

— ganadara
แหล่งที่มา

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

— กราฟิลส์

1

ขึ้นอยู่กับวิธีการนำล็อคไปใช้ หากคุณทำเช่นเดียวกับในบทความ Wikipedia เช่นการปกป้องส่วนสำคัญด้วยบูลีนเดียวต่อกระบวนการ¹แสดงว่าคุณกำลังมีปัญหา หากกระบวนการหนึ่งตายกระบวนการจะไม่รีเซ็ตสถานะของมันดังนั้นกระบวนการอื่นจึงวนซ้ำตลอดไป

ในทางปฏิบัติคุณสามารถปกป้องรหัสของคุณจากการตายหลายวิธี ตัวอย่างเช่นใช้การนำ Java-style นี้ไปใช้:

flag[1] = true;
turn = 1;
while ( flag[0] == true && turn == 1 ) { Thread.yield(); }
try {
  // critical section
}
finally {
  flag[1] = false;
}

สิ่งนี้จะทำให้แน่ใจว่าการตั้งค่าสถานะถูกรีเซ็ตสิ่งที่เกิดขึ้นในส่วนที่สำคัญตราบใดที่ระบบกำลังจัดการข้อผิดพลาด ใน Java นั้นเป็นจริงแม้แต่กับ stack และ heap overflows ดังนั้นหากกระบวนการหายไปอย่างแท้จริง ( kill²ความล้มเหลวของตัวประมวลผลการตัดการเชื่อมต่อเครือข่าย ... ) คุณปลอดภัย โปรดทราบว่าซอฟต์แวร์ที่ไม่สำคัญส่วนใหญ่จะล้มเหลวในกรณีเหล่านี้ - จะจัดการข้อผิดพลาดได้อย่างไรว่าไม่ทำงาน - เพื่อที่จะต้องได้รับการยอมรับในหลายกรณี คุณสามารถจัดการกับความไม่สอดคล้องเมื่อรีสตาร์ทหากจำเป็น

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

ที่ไม่ได้ขนาดดีอยู่แล้ว
ใน Java ฉันคิดว่าfinalizeควรจะดำเนินการแม้ในkillแต่ไม่ได้รับประกันโดย spec kill -9อาจเป็นประโยคประหารชีวิตสำหรับวิธีการแก้ปัญหาใด ๆ ที่ต้องใช้กระบวนการตายเพื่อทำอะไรบางอย่าง

— กราฟิลส์
แหล่งที่มา

1

ดูที่สมมติฐานโดยเฉพาะอย่างยิ่งว่าไม่มีกระบวนการใดที่จะอยู่ในส่วนวิกฤตไปเรื่อย ๆ (ซึ่งรวมถึงการหายไปอย่างแน่นอน) ฉันไม่คิดว่าจะมีวิธีการแก้ปัญหาทั่วไปด้วยกลไกการซิงโครไนซ์ใด ๆ

โซลูชันนี้ใช้สำหรับสองกระบวนการเท่านั้นมีวิธีแก้ไขสำหรับกระบวนการกระบวนการโดยรอบ $n$

— vonbrand
แหล่งที่มา