सिंक्रनाइज़ेशन पर नोट्स। गतिरोध

हमारे कठोर समय में, जब प्रोसेसर की शक्ति बढ़ने (आवृत्ति) बंद हो गई और चौड़ाई (थ्रेड्स की संख्या) में बढ़ने लगी, तो सिंक्रनाइज़ेशन समस्या बहुत तीव्र है। व्यवहार में इस समस्या का सामना करते हुए, मैंने खुद के लिए महसूस किया कि यह कार्य पहली नज़र में लगने की तुलना में बहुत अधिक जटिल है, और यह कितनी छुपता है। इस समस्या पर काम करने की प्रक्रिया में, मेरे पास कई दिलचस्प पैटर्न थे, जिन्हें मैं हब्रोसैक्विटी का परिचय देना चाहता हूं।


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

शुरू करने के लिए, सभी संसाधनों को साझा करने की आवश्यकता होती है जो एक विशेष आधार वर्ग से विरासत में प्राप्त होने चाहिए।

class SynchPrim { enum{ NOT_LOCKED=0 }; public: SynchPrim(): lockId_( NOT_LOCKED ){} SynchPrim( const SynchPrim& ): lockId_( NOT_LOCKED ){} SynchPrim operator =( const SynchPrim& ){} private: template< typename T >friend class SynchronizationManager; int getLockId()const{ return lockId_; } int lockId_; }; 

खैर, अभी के लिए, सब कुछ सरल है। लेकिन क्या होगा अगर हम कक्षा में एक अतिरिक्त पूर्वज जोड़ना नहीं चाहते हैं या नहीं कर सकते हैं? यह ठीक है, आपको इसके लिए केवल एक आवरण लिखना होगा:

 template< typename T > class SynchPrimWrapper : public T, public SynchPrim{}; 

और एक वस्तु की घोषणा करते समय इसका उपयोग करें:

 SynchPrimWrapper< Resource1 > resource1; 

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

सबसे पहले, हम संसाधनों की एक सूची बनाएंगे जिसके साथ हम काम करेंगे। यह या तो C- सरणी या std :: वेक्टर हो सकता है।

 SynchPrim* lock_list[] = { &resource1, &resource2, &resource3 }; 

फिर एक कॉल के साथ हम उन सभी को ब्लॉक करते हैं:

 SynchronizationManager::getInstance().lock( lock_list+0, lock_list+3 ); 

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

 SynchronizationManager::getInstance().unlock( lock_list+0, lock_list+3 ); 

खैर, वास्तव में वर्ग:

 template< class TSynchronizator >//      lock, unlock, wait, signal   ThreadType class SynchronizationManager : public Singelton< SynchronizationManager< TSynchronizator > > { public: /*         needWait -    true -   ,       false,    */ template< typename Iterator > bool lock( const Iterator& begin, const Iterator& end, bool needWait= true ); /*          */ template< typename Iterator > void unlock( const Iterator& begin, const Iterator& end ); private: TSynchronizator synh_; #ifdef _DEBUG typedef typename TSynchronizator::ThreadType ThreadId; typedef std::set< ThreadId > LockedThreads; LockedThreads lthread_; #endif }; 

एक तुल्यकालन रणनीति किसी भी साधन का उपयोग करके लिखी जा सकती है, और लगभग किसी भी मंच पर। आमतौर पर, यह म्यूटेक्स और स्थिति है।

कार्यान्वयन:

 template< class TSynchronizator > template< typename Iterator > bool SynchronizationManager< TSynchronizator >::lock( const Iterator& begin, const Iterator& end, bool needWait ) { synh_.lock(); ThreadId threadId = synh_.getThreadId(); bool isFree = false; #ifdef _DEBUG assert( lthread_.find( threadId ) == lthread_.end() ); #endif while( !( isFree = std::find_if( begin, end, std::mem_fun( &SynchPrim::getLockId ) ) == end ) && needWait ) synh_.wait(); if( isFree ) for( Iterator it = begin; it != end; it++ ) (*it)->lockId_ = threadId; #ifdef _DEBUG if( isFree ) lthread_.insert( threadId ); #endif synh_.unlock(); return isFree; } template< class TSynchronizator > template< typename Iterator > void SynchronizationManager< TSynchronizator >::unlock( const Iterator& begin, const Iterator& end ) { synh_.lock(); #ifdef _DEBUG ThreadId threadId = synh_.getThreadId(); assert( lthread_.find( threadId ) != lthread_.end() ); lthread_.erase( threadId ); #endif for( Iterator it = begin; it != end; it++ ) (*it)->lockId_ = SynchPrim::NOT_LOCKED; synh_.signal(); synh_.unlock(); } 

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