क्या पीटरसन की 2-प्रक्रिया आपसी बहिष्कार एल्गोरिदम मरने की प्रक्रियाओं के लिए है?

Question

मुझे लगता है कि आपसी बहिष्कार के लिए पीटरसन के एल्गोरिथ्म में , यदि पहले महत्वपूर्ण अनुभाग में प्रवेश करने की प्रक्रिया को मरने या रद्द किया जाना था, तो दूसरी प्रक्रिया हमेशा के लिए लूप हो जाएगी, महत्वपूर्ण अनुभाग में प्रवेश करने की प्रतीक्षा कर रही है।

तस्वीर में, यदि प्रक्रिया 1 को रोक दिया जाता है, तो प्रक्रिया 1 के पीछे की बाकी प्रक्रियाएं प्रक्रिया 1 के उस स्थान तक क्रियान्वित होंगी, लेकिन फिर लूप होती है।

क्या होता है अगर महत्वपूर्ण खंड तक पहुंचने वाली प्रक्रिया पहले इसे छोड़ने से पहले मर जाती है?

Comments

मैंने आपके प्रश्न को उसी के अनुसार संपादित किया। चूंकि आपने एल्गोरिथ्म को दो से अधिक प्रक्रियाओं तक कैसे बढ़ाया जाए, इस पर टिप्पणी नहीं की थी, इसलिए मैंने प्रश्न के उस हिस्से को बदल दिया; मुझे लगता है कि समस्या दो-प्रक्रिया संस्करण में पहले से मौजूद है। मैं अभी भी तस्वीर को बिल्कुल भी नहीं समझ पा रहा हूं।

— राफेल

Answer 1

यह इस बात पर निर्भर करता है कि ताले कैसे लागू होते हैं। यदि आप इसे विकिपीडिया लेख में करते हैं, अर्थात प्रति प्रक्रिया एक बूलियन के साथ महत्वपूर्ण खंड की रखवाली करना, तो आप निश्चित रूप से परेशानी में हैं। यदि एक प्रक्रिया मर जाती है, तो यह कभी अपने झंडे को रीसेट नहीं करता है, इसलिए दूसरी प्रक्रिया हमेशा के लिए बंद हो जाती है।

व्यवहार में, आप मरने के कई तरीकों के खिलाफ अपने कोड को सुरक्षित रख सकते हैं। उदाहरण के लिए, इस जावा-शैली के कार्यान्वयन को लें:

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

यह सुनिश्चित करेगा कि महत्वपूर्ण खंड में जो कुछ भी हो, ध्वज को रीसेट कर दिया जाए, जब तक कि सिस्टम त्रुटि को संभाल रहा है। जावा में, स्टैक और हीप ओवरफ्लो के लिए भी यह सच है। तो जब तक यह प्रक्रिया वस्तुतः गायब नहीं हो जाती ( kill², प्रोसेसर विफलता, नेटवर्क डिस्कनेक्ट, ...) आप सुरक्षित हैं। ध्यान दें कि अधिकांश गैर-महत्वपूर्ण सॉफ़्टवेयर इन मामलों में विफल रहता है - यह एक त्रुटि को कैसे संभाल सकता है जो यह नहीं चल रहा है? - ताकि कई मामलों में स्वीकार किया जा सके। यदि आवश्यक हो तो आप पुनः आरंभ करने पर विसंगतियों को संभाल सकते हैं।

यदि आप उचित, भाषा-स्तर के ताले का उपयोग करते हैं, तो रनटाइम सिस्टम गायब हो जाने वाले लॉक मालिकों को संभाल सकता है, अर्थात मृत मालिकों के साथ लॉक जारी कर सकता है। आप प्रत्येक प्रक्रिया को एक मृत आदमी के स्विच को दे सकते हैं, जिसे दूसरे पढ़ सकते हैं, या सीधे देख सकते हैं कि क्या लॉक ऑनिंग प्रक्रिया अभी भी जीवित है (यदि सिस्टम इसका समर्थन करता है) देकर इसे स्वयं अनुकरण कर सकता है।

---

1. वैसे भी इसका कोई पैमाना नहीं होता।
2. जावा में, मुझे लगता है कि इस finalizeपर भी अमल करना चाहिए kill, लेकिन यह युक्ति से अनुमान नहीं है। kill -9शायद किसी भी समाधान के लिए मौत की सजा है जिसे कुछ करने के लिए मरने की प्रक्रिया की आवश्यकता होती है।

Answer 2

मान्यताओं को देखें, विशेष रूप से कि कोई भी प्रक्रिया महत्वपूर्ण खंड में अनिश्चित काल तक नहीं रहती (जिसमें निश्चित रूप से बस दूर जाना शामिल है)। मुझे नहीं लगता कि किसी भी तुल्यकालन तंत्र के साथ उस सामान्य समस्या को हल करने का एक तरीका है।

यह समाधान भी केवल दो प्रक्रियाओं के लिए है, के लिए समाधान हैं$n$ प्रक्रियाओं के आसपास।