कोड में छिपा हुआ समरूपता और त्रुटि पैटर्न: गतिरोध

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



यह जानकारी हमें संस्थान में मिलती है, यह इंटरनेट पर पुस्तकों और लेखों में पाया जा सकता है। इस तरह के गतिरोध का उपयोग, उदाहरण के लिए, दो म्यूटेक्स, इसकी सभी महिमा में कोड में पाया जा सकता है। लेकिन ज्यादातर मामलों में, सब कुछ इतना सरल नहीं है, और हर कोई कोड में क्लासिक त्रुटि पैटर्न नहीं देख सकता है यदि इसे सामान्य रूप में प्रस्तुत नहीं किया गया है।



उस वर्ग पर विचार करें जिसमें हम StartUpdate, CheckAndUpdate और Stop विधियों में रुचि रखते हैं, C ++ का उपयोग किया जाता है, कोड यथासंभव सरल है:

std::recursive_mutex m_mutex; Future m_future; void Stop() { std::unique_lock scoped_lock(m_mutex); m_future.Wait(); // do something } void StartUpdate() { m_future.Wait(); m_future = Future::Schedule(std::bind(&Element::CheckAndUpdate, this), std::chrono::milliseconds(100); } void CheckAndUpdate() { std::unique_lock scoped_lock(m_mutex); //do something } 

आपको प्रस्तुत कोड में क्या ध्यान देना चाहिए:

1. पुनरावर्ती म्यूटेक्स का उपयोग किया जाता है। एक पुनरावर्ती म्यूटेक्स के बार-बार कब्जा होने पर केवल अपेक्षा ही नहीं होती है अगर ये कैप्चर उसी थ्रेड में होते हैं। इस मामले में, म्यूटेक्स छूट की संख्या कैप्चर की संख्या के अनुरूप होनी चाहिए। यदि हम एक पुनरावर्ती म्यूटेक्स पर कब्जा करने की कोशिश करते हैं जो पहले से ही दूसरे धागे में कैप्चर किया जाता है, तो धागा स्टैंडबाय मोड में चला जाता है।
2. भविष्य :: अनुसूची फ़ंक्शन शुरू होता है (n मिलीसेकंड में) एक अलग थ्रेड में कॉलबैक इसे पारित कर दिया

अब हम प्राप्त सभी सूचनाओं का विश्लेषण करते हैं और चित्र बनाते हैं:



ऊपर प्रस्तुत दो तथ्यों को ध्यान में रखते हुए, यह निष्कर्ष निकालना मुश्किल नहीं है कि कार्यों में से एक में एक पुनरावर्ती म्यूटेक्स पर कब्जा करने का प्रयास म्यूटेक्स की रिहाई की उम्मीद को जन्म देगा यदि यह पहले से ही किसी अन्य फ़ंक्शन में कैप्चर किया गया था, क्योंकि CheckAndUpdate कॉलबैक हमेशा एक अलग थ्रेड में निष्पादित होता है।

पहली नज़र में, गतिरोध के बारे में कुछ भी संदिग्ध नहीं है। लेकिन अधिक निकट होने के लिए, यह सब हमारे क्लासिक चित्र पर आता है। जब कार्यात्मक वस्तु निष्पादित होने लगती है, तो हम सीधे m_future संसाधन, कॉलबैक को सीधे कैप्चर करते हैं
m_future से जुड़ा:



गतिरोध के लिए जाने वाले कार्यों का क्रम इस प्रकार है:

1. इसे CheckAndUpdate चलाने की योजना है, लेकिन n मिलीसेकंड के बाद कॉलबैक तुरंत शुरू नहीं होता है।
2. स्टॉप विधि कहा जाता है, और फिर यह शुरू होता है: हम म्यूटेक्स पर कब्जा करने की कोशिश करते हैं - संसाधन एक पर कब्जा कर लिया है, हम पूरा होने के लिए m_future का इंतजार करना शुरू करते हैं - ऑब्जेक्ट को अभी तक नहीं बुलाया गया है, हम इंतजार कर रहे हैं।
3. CheckAndUpdate का निष्पादन शुरू होता है: हम म्यूटेक्स पर कब्जा करने की कोशिश करते हैं - हम नहीं कर सकते, संसाधन पहले से ही एक और धागा द्वारा कब्जा कर लिया गया है, हम रिलीज़ होने की प्रतीक्षा कर रहे हैं।

यह सब है: स्टॉप कॉल करने वाला धागा CheckAndUpdate के पूरा होने का इंतजार करता है, और दूसरा धागा, तब तक काम करना जारी नहीं रख सकता, जब तक कि यह म्यूटेक्स को पकड़ नहीं लेता है जो पहले बताए गए थ्रेड द्वारा कैप्चर किया गया है। यह काफी क्लासिक गतिरोध है। आधा काम पूरा हो गया है - समस्या का कारण पता चला है।


यहाँ एक स्पष्ट गतिरोध के साथ ऐसा सीधा उदाहरण है जो आसानी से इस त्रुटि के पैटर्न को कम कर देता है। अंत में, मैं आपको विश्वसनीय और थ्रेड सुरक्षित कोड लिखना चाहता हूं!