क्या आप लॉक ऑर्डरिंग की व्याख्या करेंगे?

Question

मैंने सीखा कि मुझे ऑर्डर लॉक करने के लिए रिवर्स ऑर्डर अनलॉक करना चाहिए। उदाहरण के लिए ।

A.lock(); 
B.lock(); 
B.unlock(); 
A.unlock(); 

लेकिन, क्या हुआ अगर मैं इस तरह किया होती हैं:

A.lock(); 
B.lock(); 
A.unlock(); 
B.unlock(); 

मैं एक गतिरोध परिदृश्य, बनाने की कोशिश, लेकिन अगर मैं हमेशा एक पहले तो बी ताला, तो मैं पता नहीं कैसे डेडलॉक होगा। क्या आप मेरी मदद करेंगे?

Answer 1

लॉक ऑर्डरिंग का मतलब है कि आप निश्चित क्रम में ताले प्राप्त करके डेडलॉक्स को रोकते हैं, और अनलॉक करना प्रारंभ करने के बाद फिर से लॉक प्राप्त नहीं करते हैं।

मुझे नहीं लगता कि अनलॉक के आदेश (वास्तव में, यह जितनी जल्दी हो सके एक अवरोध खोल के लिए फायदेमंद हो सकता है, यहां तक ​​कि आदेश से बाहर हैं)

Answer 2

आपका उदाहरण के लिए जा रहा नहीं है यहाँ किसी भी फर्क नहीं पड़ता है अपने साथ कभी भी डेडलॉक। रिवर्स ऑर्डर में अनलॉक करना महत्वपूर्ण नहीं है, यह लगातार क्रम में लॉक हो रहा है। यह लॉक होगा, भले ही अनलॉक रिवर्स ऑर्डर

Thread 1 

A.lock(); 
B.lock(); 
B.unlock(); 
A.unlock(); 

Thread 2 

B.lock(); 
A.lock(); 
A.unlock(); 
B.unlock(); 

Answer 3

मुझे नहीं लगता कि डेडलॉक यहां होगा। सामान्य डेडलॉक अवधारणा एक धागा अन्य थ्रेड द्वारा लॉक कुछ संसाधनों के लिए इंतजार कर रही है, जबकि अन्य थ्रेड को पहले धागे द्वारा लॉक संसाधन को पहले समाप्त करने और संसाधन को रिलीज़ करने की आवश्यकता होती है।

Further reading

Answer 4

अनलॉक के आदेश को प्रभावित नहीं करेगा कैसे प्रवण आपके सिस्टम गतिरोध के लिए है, लेकिन वहाँ एक कारणों अनलॉक के आदेश के बारे में सोचना है:

आदेश गतिरोध से बचने के लिए आप चाहिए मेकअप सुनिश्चित करें कि आपके लॉक/अनलॉक जोड़े गए हैं, जिसमें आप कभी अनलॉक नहीं करते हैं। एक स्टाइलिस्ट दृष्टिकोण के रूप में, एक कणिका लॉक के लिए ज़िम्मेदार कोड के ब्लॉक होने के कारण, यह स्पष्ट रूप से पहचानने के लिए बहुत आसान है कि ताले और अनलॉक जोड़े जाते हैं। अंत-प्रभाव यह है कि स्पष्ट रूप से सही कोड शायद आपके द्वारा वर्णित ताले ले जाएगा और ताले को छोड़ देगा।

Answer 5

दिए गए साधारण मामले में, रिवर्स ऑर्डर में अनलॉक करना डेडलॉक से बचने के लिए आवश्यक नहीं है।

हालांकि, क्योंकि कोड अधिक जटिल हो जाता है, रिवर्स ऑर्डर में अनलॉक करने से आपको उचित लॉक ऑर्डरिंग में मदद मिलती है।

विचार करें: एक पुनः प्राप्त करने के लिए

A.lock(); 
B.lock(); 
Foo(); 
A.unlock(); 
Bar(); 
B.unlock(); 

Bar() तो प्रयास करता है, आप प्रभावी रूप से अपने लॉक आदेश टूट गए हैं। आप बी धारण कर रहे हैं और फिर ए प्राप्त करने की कोशिश कर रहे हैं। अब यह डेडलॉक कर सकता है।

आप उलटे क्रम शैली में अनलॉक हो (जिसमें बहुत ही स्वाभाविक है अगर आप आरए II का उपयोग करें):

A.lock(); 
B.lock(); 
Foo(); 
B.unlock(); 
Bar(); 
A.unlock(); 

तो

अगर Bar() प्रयास एक ताला लेने के लिए यह कोई बात नहीं, के रूप में ताला आदेश संरक्षित किया जाएगा ।

Answer 6

और जावा के लिए, अनलॉकिंग रिवर्स ऑर्डर में है यदि synchronized कीवर्ड लॉकिंग के लिए उपयोग किया जाता है। synchronized कीवर्ड का उपयोग करने के लिए किसी भिन्न क्रम में अनलॉक करने का कोई तरीका नहीं है।

synchronized(a) { 
    synchronized(b) { 
    // statements 
    } 
} 

Answer 7

 > lock(B)                                                 
     > ---------- lock(C) 
     > ---------- lock(B) >>>> would block here 
     > ---------- release(B) 
     > ---------- release(C) 
     > lock(C)  >>>>>> would block here 
     > release(B) 
     > release(C) 

उनका जवाब महान, यहाँ है एक और स्थिति एक गतिरोध उत्पन्न हो सकती है अगर अव्यवस्थित ताला & रिलीज किया जाता है है। एक शब्द, अनॉर्डर्ड रिलीज & लॉक उस धारणा को तोड़ता है जिसे हम अपने साझा संसाधन प्रबंधन और महत्वपूर्ण क्षेत्र को डिजाइन करने के लिए उपयोग करते थे।