उपयोगी सी ++ बहुपरत मुहावरे

परिचय

यह लेख लेखों की एक श्रृंखला की एक निरंतरता है: सिंगलटन पैटर्न का उपयोग करना [1] , सिंगलटन और ऑब्जेक्ट लाइफटाइम [2] , डिजाइन पैटर्न [3] पर निर्भरता को संभालने और उत्पन्न करना, एक बहु-थ्रेडेड एप्लिकेशन [4] में सिंगलटन कार्यान्वयन । अब मैं मल्टीथ्रेडिंग के बारे में बात करना चाहूंगा। यह विषय इतना बड़ा और बहुआयामी है कि इसे कवर करना संभव नहीं है। यहां मैं कुछ व्यावहारिक चीजों पर ध्यान केंद्रित करूंगा, जो आपको मल्टीथ्रेडिंग के बारे में बिल्कुल भी नहीं सोचने देंगे, अच्छी तरह से, या इसके बारे में बहुत कम मात्रा में सोचने के लिए। अधिक सटीक रूप से, इसके बारे में केवल डिजाइन चरण में सोचना है, लेकिन कार्यान्वयन नहीं। यानी प्रश्नों पर चर्चा की जाएगी कि कैसे सुनिश्चित करें कि बिना सिरदर्द के सही निर्माण को स्वचालित रूप से कहा जाता है। यह दृष्टिकोण, बदले में, दौड़ की स्थिति (रेस स्थिति, रेस स्थिति [5] ) और गतिरोध (गतिरोध, डेडलॉक [6] देखें) के कारण होने वाली समस्याओं को काफी कम कर सकता है। यह तथ्य अपने आप में काफी महत्वपूर्ण है। एक दृष्टिकोण पर भी विचार किया जाएगा जो आपको किसी भी ताले और परमाणु संचालन का उपयोग किए बिना एक साथ कई थ्रेड्स से ऑब्जेक्ट तक पहुंचने की अनुमति देता है!

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

उपयोग करने के लिए संस्थाएँ:

म्यूटेक्स इंटरफ़ेस विवरण: struct Mutex { void lock(); void unlock(); private: // OS specific ... };

RAII आदिम (अपवाद-सुरक्षित): struct Lock { Lock(Mutex& mutex_) : mutex(mutex_) { mutex.lock(); } ~Lock() { mutex.unlock(); } private: Mutex& mutex; };

एक सरल उदाहरण के रूप में बदमाशी के लिए एक वर्ग: struct A { int data; mutable Mutex m; };

उपयोग के उदाहरण:

उदाहरण 1. आदिम दृष्टिकोण: सी-शैली A a; amlock(); a.data = 10; amunlock();

उदाहरण 2. उन्नत दृष्टिकोण: RAII- शैली A a; { Lock lock(am); a.data = 10; }

उदाहरण 3. व्यावहारिक रूप से आदर्श: तालों का इनकैप्सुलेशन struct B { void setData(int data_) { Lock lock(m); data = data_; } int getData() const { Lock lock(m); return data; } private: mutable Mutex m; int data; }; B b; b.setData(10); int x = b.getData();

यह ध्यान देने योग्य है कि मल्टीथ्रेडिंग के बारे में लेखों में अंतिम विकल्प शायद ही कभी देखा जाता है, जो एक बहुत ही दुखद तथ्य है: मल्टीथ्रेडिंग, सामान्य डेटा और म्यूटेक्स [9] , क्रॉस-प्लेटफॉर्म मल्टीथ्रेडेड एप्लिकेशन [10] , सी ++ 11 में स्ट्रीम, लॉक और सशर्त चर (भाग २) [११] । यह लेख उन दिलचस्प मुद्दों पर चर्चा करेगा जो बहु-थ्रेडेड प्राइमेटिव्स के साथ काम को आसान बनाने में मदद करेंगे (देखें धाराएँ, ताले और C ++ 11 (भाग 1) में सशर्त चर [12] , mxxes पर आपसी ताले को रोकने के लिए दो सरल नियम [13] )। कुछ मायनों में, यह लेख सिंक्रोनाइज़्ड वैल्यूज़ [14] के साथ एनफोर्सिंग करेक्ट म्यूटेक्स यूज़ से लिए गए विचारों का विकास होगा। हालांकि, नीचे दिए गए विचारों और कार्यान्वयन के तरीकों को लेख के स्वतंत्र रूप से विकसित किया गया था।

अचल

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

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

कल्पना कीजिए कि हमारी कक्षा में एक isValid तरीका है, जो कि यदि isValid को बचाया जाता है, और false का उल्लंघन होने पर false तरीके से true हो जाता है। निम्नलिखित "गैर-नकारात्मक" काउंटर पर विचार करें:

 struct Counter { Counter() : count(0) {} bool isValid() const { return count >= 0; } int get() const { return count; } void set(int newCount) { count = newCount; } void inc() { ++ count; } void dec() { -- count; } private: int count; }; 

का उपयोग करें:

 Counter c; c.set(5); assert(c.isValid()); //  true c.set(-3); assert(c.isValid()); //  false   assert 

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

यहां हम लेखों की पिछली श्रृंखला में विकसित किए गए औजारों का उपयोग करेंगे: सिंगलटन पैटर्न [1] , सिंगलटन और ऑब्जेक्ट लाइफटाइम [2] का उपयोग , डिपेंडेंसी हैंडलिंग और डिजाइन पैटर्न का निर्माण [3] , मल्टी-थ्रेडेड एप्लिकेशन [4] में सिंगलटन कार्यान्वयन । नीचे, मैं एक कार्यान्वयन के संदर्भ के लिए दूंगा जो युग्मन से गुजरेंगे:

get0 जांच करने में सक्षम होने के लिए, हम वस्तु तक पहुंच को संशोधित करते हैं (निजी विधि get0 ) निम्नानुसार है:

 template<typename T> struct An { // ... T* get0() const { const_cast<An*>(this)->init(); assert(data->isValid()); //  assert return data.get(); } // ... }; 

सब ठीक है, सत्यापन प्रगति पर है। लेकिन परेशानी यह है: यह परिवर्तन के बाद नहीं होता, बल्कि पहले होता है। इस प्रकार, वस्तु असंगत स्थिति में हो सकती है, और केवल निम्नलिखित कॉल अपना काम करेगी:

 c->set(2); c->set(-2); //  assert   c->set(1); //     ,    ! 

मैं चाहता हूं कि बदलाव के बाद जांच हो, और इससे पहले नहीं। ऐसा करने के लिए, हम एक प्रॉक्सी ऑब्जेक्ट का उपयोग करेंगे, जिसके विनाश में आवश्यक सत्यापन होगा:

 template<typename T> struct An { // ... struct Access { Access(T& ref_) : ref(ref_) {} ~Access() { assert(ref.isValid()); } T* operator->() { return &ref; } private: T& ref; }; // ,  ( , ..     ): Access operator->() { return *get0(); } // ... }; 

का उपयोग करें:

 An<Counter> c; c->set(2); c->set(-2); //  assert   c->set(1); 

जिसकी आवश्यकता थी।

स्मार्ट म्यूटेक्स

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

इसे तैयार करने के लिए, हमें एक "नियमित" म्यूटेक्स की आवश्यकता है (बस एक स्मार्ट पॉइंटर की तरह, हमें एक नियमित पॉइंटर की आवश्यकता है):

 // noncopyable struct Mutex { //    void lock(); void unlock(); private: // ... }; 

अब हम पहले प्रयोग किए गए व्यवहारों में सुधार करेंगे, ताकि पहले से ही इनवेटर की जाँच की जा सके। ऐसा करने के लिए, हम न केवल प्रॉक्सी वर्ग विध्वंसक का उपयोग करेंगे, बल्कि निर्माता भी:

 template<typename T> struct AnLock { // ... template<typename U> struct Access { //     Access(const An& ref_) : ref(ref_) { ref.mutex->lock(); } //      ~Access() { ref.mutex->unlock(); } U* operator->() const { return ref.get0(); } private: const An& ref; }; //       Access<T> operator->() { return *this; } Access<const T> operator->() const { return *this; } //    template<typename U> U& create() { U* u = new U; data.reset(u); mutex.reset(new Mutex); return *u; } private: // ... std::shared_ptr<T> data; std::shared_ptr<Mutex> mutex; }; 

का उपयोग करें:

 AnLock<Counter> c; c->set(2); //   std::cout << "Extracted value: " << c->get() << std::endl; 

यह ध्यान देने योग्य है कि एक निरंतर लिंक का उपयोग करते समय, मूल्य को बदलने से एक संकलन त्रुटि हो जाएगी (जैसा कि सीधे shared_ptr करने के लिए विरोध किया गया है):

 const AnLock<Counter>& cc = c; cc->set(3); //     

गौर कीजिए कि हमें क्या मिला। Counter और Mutex के तरीकों के लिए स्क्रीन आउटपुट को जोड़ने पर, हमें निम्न स्क्रीन आउटपुट मिलते हैं जब मूल्य बदल जाता है:

 म्यूटेक्स :: लॉक
 काउंटर :: सेट: 2
 म्यूटेक्स :: अनलॉक

स्क्रीन पर प्रदर्शित होने पर क्रियाओं का क्रम:

 म्यूटेक्स :: लॉक
 काउंटर :: प्राप्त करें: 2
 निकाला गया मान: २
 म्यूटेक्स :: अनलॉक

सुविधा स्पष्ट है: म्यूटेक्स को स्पष्ट रूप से कॉल करने के बजाय, हम बस ऑब्जेक्ट के साथ काम करते हैं जैसे कि कोई म्यूटेक्स नहीं है, और जो कुछ भी अंदर आवश्यक है वह होता है।

एक पूछ सकता है: अगर मुझे ज़रूरत है तो मुझे क्या करना चाहिए, उदाहरण के लिए, 2 बार कॉल करने के लिए, और इसे परमाणु रूप से करना चाहिए? कोई बात नहीं! सबसे पहले, सुविधा के लिए हमारे AnLock वर्ग में कुछ जोड़े AnLock :

 template<typename T> struct AnLock { // ... typedef Access<T> WAccess; //    typedef Access<const T> RAccess; //    // ... }; 

और फिर निम्नलिखित निर्माण का उपयोग करें:

 { AnLock<Counter>::WAccess a = c; a->inc(); a->inc(); } 

जो, बदले में, निम्नलिखित निष्कर्ष देता है:

 म्यूटेक्स :: लॉक
 काउंटर :: inc: 1
 काउंटर :: inc: 2
 म्यूटेक्स :: अनलॉक

लेन-देन जैसा कुछ है, है ना?

स्मार्ट आरडब्ल्यू म्यूटेक्स

इसलिए, अब हम थोड़ा और अधिक जटिल निर्माण को लागू करने का प्रयास कर सकते हैं जिसे रीड-राइट म्यूटेक्स कहा जाता है ( पाठक पढ़ें - लेखक ताला [7] )। उपयोग का सार काफी सरल है: कई धाराओं से ऑब्जेक्ट डेटा को पढ़ने की क्षमता की अनुमति देने के लिए, जबकि एक साथ पढ़ना और लिखना या लिखना और लिखना निषिद्ध होना चाहिए।

मान लीजिए कि हमारे पास पहले से ही इस इंटरफ़ेस के साथ एक RWMutex कार्यान्वयन है:

 // noncopyable struct RWMutex { //    //   void rlock(); void runlock(); //   void wlock(); void wunlock(); private: // ... }; 

ऐसा लगता है कि यह सब करने की ज़रूरत है ताकि कार्यान्वयन को थोड़ा बदल दिया जा सके ताकि हमारे प्रॉक्सी प्रकार RAccess और WAccess विभिन्न कार्यों का उपयोग करें:

 template<typename T> struct AnRWLock { // ... //    struct RAccess { RAccess(const AnRWLock& ref_) : ref(ref_) { ref.mutex->rlock(); } ~RAccess() { ref.mutex->runlock(); } const T* operator->() const { return ref.get0(); } private: const AnRWLock& ref; }; //    struct WAccess { WAccess(const AnRWLock& ref_) : ref(ref_) { ref.mutex->wlock(); } ~WAccess() { ref.mutex->wunlock(); } T* operator->() const { return ref.get0(); } private: const AnRWLock& ref; }; WAccess operator->() { return *this; } RAccess operator->() const { return *this; } // ... //    template<typename U> U& create() { U* u = new U; data.reset(u); mutex.reset(new RWMutex); return *u; } private: // ... std::shared_ptr<T> data; std::shared_ptr<RWMutex> mutex; }; 

का उपयोग करें:

 AnRWLock<Counter> c; c->set(2); 

परिणाम:

 RWMutex :: wlock
 काउंटर :: सेट: 2
 RWMutex :: wunlock

अब तक तो अच्छा है! लेकिन निम्नलिखित कोड:

 std::cout << "Extracted value: " << c->get() << std::endl; 

यह देता है:

 RWMutex :: wlock
 काउंटर :: प्राप्त करें: 2
 निकाला गया मान: २
 RWMutex :: wunlock

कुछ के लिए, यह एक आश्चर्य के रूप में नहीं आएगा, लेकिन बाकी के लिए, मैं समझाऊंगा कि यह अपेक्षा के अनुरूप काम क्यों नहीं करता है। आखिरकार, हमने निरंतर विधि का उपयोग किया, इसलिए सिद्धांत रूप में निरंतर विधि operator-> उपयोग किया जाना चाहिए था। हालांकि, कंपाइलर ऐसा नहीं सोचता। और यह इस तथ्य के कारण है कि संचालन को क्रमिक रूप से लागू किया जाता है: सबसे पहले, ऑपरेशन -> गैर-स्थिर ऑब्जेक्ट पर लागू होता है, और फिर निरंतर विधि Counter::get कहा जाता है, लेकिन ट्रेन छोड़ दी, क्योंकि गैर-स्थिर operator-> को पहले ही बुलाया जा चुका है।

एक तुच्छ समाधान के रूप में, हम ऑब्जेक्ट तक पहुँचने से पहले निरंतर कास्टिंग के विकल्प का प्रस्ताव कर सकते हैं:

 const AnRWLock<Counter>& cc = c; std::cout << "Extracted value: " << cc->get() << std::endl; 

परिणाम के साथ:

 RWMutex :: rlock
 काउंटर :: प्राप्त करें: 2
 निकाला गया मान: २
 RWMutex :: रनलॉक

लेकिन यह समाधान दिखता है, इसे हल्के ढंग से लगाने के लिए, बहुत आकर्षक नहीं। मैं बस और संक्षेप में लिखना चाहता हूं, और हर कॉल के साथ भारी तरीकों का उपयोग न करें।

इस समस्या को हल करने के लिए, हम एक नए ऑपरेटर का परिचय करते हैं, लंबा तीर ---> , जो ऑब्जेक्ट को लिखेगा, अर्थात्। गैर-निरंतर तरीकों तक पहुंच, और सामान्य (संक्षिप्त) तीर -> पढ़ने के लिए छोड़ दें। पढ़ने के लिए छोटे तीर और लिखने के लिए लंबे तीर का उपयोग करने के लिए, और इसके विपरीत नहीं, इस प्रकार हैं:

1. दृश्य । आप तुरंत देख सकते हैं कि कहां ऑपरेशन का उपयोग किया जाता है।
2. शब्दार्थ । पढ़ना एक वस्तु का एक प्रकार का सतही उपयोग है: इसे छुआ और जारी किया जाता है। एक रिकॉर्ड एक गहरा ऑपरेशन है, एक परिवर्तन है, इसलिए बोलने के लिए, इनसाइड्स का, और इसलिए तीर लंबा है।
3. व्यावहारिक । जब एक आरडब्ल्यू-म्यूटेक्स के साथ एक नियमित म्यूटेक्स की जगह लेते हैं, तो आपको इन स्थानों में लंबे तीर के साथ छोटे तीर को बदलकर संकलन त्रुटियों को ठीक करने की आवश्यकता है, और सब कुछ सबसे इष्टतम तरीके से काम करेगा।

यहाँ, शायद, चौकस पाठक ने सवाल पूछा: लेख के लेखक के रूप में एक ही खरपतवार कहाँ प्राप्त करें? आखिरकार


आइए कार्यान्वयन को देखें:

 //  , : WAccess operator--(int) { return *this; } //  , : RAccess operator->() const { return *this; } 

का उपयोग करें:

 AnRWLock<Counter> c; //   : c->set(2) c--->set(2); 

क्रियाओं का क्रम:

 RWMutex :: wlock
 काउंटर :: सेट: 2
 RWMutex :: wunlock

लंबे तीर का उपयोग करने के अलावा, सब कुछ पहले की तरह है। हम आगे देखते हैं:

 std::cout << "Extracted value: " << c->get() << std::endl; 

 RWMutex :: rlock
 काउंटर :: प्राप्त करें: 2
 निकाला गया मान: २
 RWMutex :: रनलॉक

मेरी राय में, लेखन ऑपरेशन के लिए एक लंबे तीर का उपयोग करना उचित है: यह हमारी समस्या को हल करता है, और बहुत ही सुरुचिपूर्ण तरीके से।

कॉपी-ऑन-राइट

इसके बाद, निम्नलिखित दिलचस्प और उपयोगी मुहावरे पर विचार करें: कॉपी-ऑन-राइट ( गाय ), या कॉपी पर लिखें [8] । जैसा कि नाम का अर्थ है, मुख्य विचार यह है कि किसी ऑब्जेक्ट के डेटा को बदलने से तुरंत पहले, एक नए मेमोरी लोकेशन पर कॉपी करना पहले होता है, और फिर डेटा को एक नए पते पर बदल दिया जाता है।

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

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

 template<typename T> struct AnCow { // ... //      T* operator--(int) { return getW0(); } //      const T* operator->() const { return getR0(); } //   (   !) void clone() { data.reset(new T(*data)); } // ... private: T* getR0() const { const_cast<An*>(this)->init(); return data.get(); } T* getW0() { init(); //    “”  if (!data.unique()) clone(); return data.get(); } 

यह ध्यान देने योग्य है कि पॉलीमॉर्फिक ऑब्जेक्ट्स का उपयोग यहां नहीं माना जाता है (यानी, हम कभी भी टेम्पलेट क्लास T उत्तराधिकारी नहीं बनाते हैं), क्योंकि यह इस लेख के दायरे से परे है। अगले लेख में मैं इस मुद्दे का एक विस्तृत समाधान देने की कोशिश करूंगा, जबकि कार्यान्वयन काफी असामान्य होगा।

चलो का उपयोग करने के लिए आगे बढ़ते हैं:

कोड	कंसोल आउटपुट
AnCow<Counter> c; c--->set(2);	काउंटर :: सेट: 2
std::cout << "Extracted value: " << c->get() << std::endl;	काउंटर :: प्राप्त करें: 2 निकाला गया मान: २
AnCow<Counter> d = c; std::cout << "Extracted value: " << d->get() << std::endl;	काउंटर :: प्राप्त करें: 2 निकाला गया मान: २
d--->inc();	काउंटर कॉपी ctor: 2 काउंटर :: inc: 3
c--->dec();	काउंटर :: डिक: 1

बहुत शुरुआत में, कुछ भी दिलचस्प नहीं होता है: मूल्य सेट करना और स्क्रीन पर समान मूल्य प्रदर्शित करना 2 । अगला, मान एक नए चर को सौंपा गया है, जबकि ऑब्जेक्ट डेटा का उपयोग समान है। जब आउटपुट d->get() , उसी ऑब्जेक्ट का उपयोग किया जाता है।

फिर, जब d--->inc() कहा जाता है, तो सबसे दिलचस्प बात यह होती है: पहले वस्तु की प्रतिलिपि बनाई जाती है, और फिर परिणामी मान 3 तक बढ़ा दिया जाता है। अगली कॉल c--->dec() प्रतिलिपि नहीं है, क्योंकि स्वामी अब केवल एक है और हमारे पास ऑब्जेक्ट की दो अलग-अलग प्रतियां हैं। मुझे लगता है कि यह उदाहरण स्पष्ट रूप से गाय के काम को दिखाता है।

मेमोरी में की-वैल्यू स्टोरेज

अंत में, हम विकसित तकनीकों का उपयोग करते हुए बहु-थ्रेडेड वातावरण में काम करते समय मेमोरी में कुंजी-मूल्य भंडारण के कार्यान्वयन के कुछ रूपों पर विचार करते हैं।

हम अपने भंडार के लिए निम्नलिखित कार्यान्वयन का उपयोग करेंगे:

 template<typename T_key, typename T_value> struct KeyValueStorageImpl { //     void set(T_key key, T_value value) { storage.emplace(std::move(key), std::move(value)); } //   T_value get(const T_key& key) const { return storage.at(key); } //   void del(const T_key& key) { storage.erase(key); } private: std::unordered_map<T_key, T_value> storage; }; 

अगले जोड़तोड़ को आसान बनाने के लिए सिंगलटन को स्टोरेज को बांधें (देखें सिंगलटन पैटर्न का उपयोग करते हुए [1] ):

 template<typename T_key, typename T_value> void anFill(AnRWLock<KeyValueStorageImpl<T_key, T_value>>& D_an) { D_an = anSingleRWLock<KeyValueStorageImpl<T_key, T_value>>(); } 

इस प्रकार, AnRWLock<KeyValueStorageImpl<T,V>> का उदाहरण बनाते समय, सिंगलटन से निकाली गई वस्तु को "डाला" जाएगा, अर्थात्। AnRWLock<KeyValueStorageImpl<T,V>> हमेशा एक ही उदाहरण के लिए इंगित करेगा।

संदर्भ के लिए, मैं उपयोग किए गए बुनियादी ढांचे को दे दूंगा:

अगला, सरल से जटिल तक, इस भंडार का उपयोग करने के विभिन्न तरीकों पर विचार किया जाएगा।

उदाहरण 1. सबसे सरल उपयोग।

हम बिना अतिरिक्त तामझाम के सीधे भंडारण का उपयोग करेंगे:

 //        template<typename T_key, typename T_value> struct KeyValueStorage : AnRWLock<KeyValueStorageImpl<T_key, T_value>> { typedef T_value ValueType; }; 

उपयोग उदाहरण:

कोड	कंसोल आउटपुट
// - // - KeyValueStorage<std::string, int> kv; kv--->set("Peter", 28);	RWMutex :: wlock की-वैल्यू: इंसर्टिंग की: पीटर RWMutex :: wunlock
kv--->set("Nick", 25);	RWMutex :: wlock की-वैल्यू: इंसर्टिंग की: निक RWMutex :: wunlock
std::cout << "Peter age: " << kv->get("Peter") << std::endl;	RWMutex :: rlock कुंजी-मूल्य: निकालने की कुंजी: पीटर पीटर की उम्र: 28 RWMutex :: रनलॉक

पहली पंक्ति में, हम एक kv ऑब्जेक्ट बनाते हैं जिसमें एक एकल (एकल anFill फ़ंक्शन देखें) का उपयोग करके भंडार का एक एकल उदाहरण डाला जाता है। इसके बाद, पीटर और निक को जोड़ा जाता है, और फिर पीटर की आयु प्रदर्शित की जाती है।

मुझे लगता है कि आउटपुट से यह स्पष्ट है कि राइट-लॉक स्वचालित रूप से लिखते समय लिया जाता है, और रीड-लॉक को पढ़ने के दौरान लिया जाता है।

उदाहरण 2. नेस्टेड आरडब्ल्यू म्यूटेक्स।

थोड़ा और जटिल उदाहरण पर विचार करें।मान लीजिए कि अब हम नामांकित काउंटर प्राप्त करना चाहते हैं Counterऔर उन्हें कई थ्रेड से उपयोग करना चाहते हैं । कोई समस्या नहीं:

 //   ,        AnRWLock template<typename T_key, typename T_value> struct KeyValueStorageRW : KeyValueStorage<T_key, AnRWLock<T_value>> { }; //      typedef KeyValueStorageRW<std::string, Counter> KVRWType; 

उपयोग उदाहरण:

कोड	कंसोल आउटपुट
KVRWType kv; // AnRWLockAutoCreate - kv--->set("users", AnRWLockAutoCreate<Counter>());	RWMutex :: wlock की-वैल्यू: इंसर्टिंग की: उपयोगकर्ता RWMutex :: wunlock
kv--->set("sessions", AnRWLockAutoCreate<Counter>());	RWMutex :: wlock की-वैल्यू: इंसर्टिंग की: सेशन RWMutex :: wunlock
kv->get("users")--->inc();	RWMutex :: rlock मुख्य-मूल्य: कुंजी निकालना: उपयोगकर्ता RWMutex :: wlock काउंटर :: inc: 1 RWMutex :: wunlock RWMutex :: रनलॉक
kv->get("sessions")--->inc();	RWMutex :: rlock कुंजी-मूल्य: कुंजी निकालना: सत्र RWMutex :: wlock काउंटर :: inc: 1 RWMutex :: wunlock RWMutex :: रनलॉक
kv->get("sessions")--->dec();	RWMutex :: rlock कुंजी-मूल्य: कुंजी निकालना: सत्र RWMutex :: wlock काउंटर :: डिक: 0 RWMutex :: wunlock RWMutex :: रनलॉक

जैसा कि वे कहते हैं, आवाज!

उदाहरण 3. पहुँच का अनुकूलन।

यद्यपि मैं अगले लेख में कुछ अनुकूलन के बारे में बात करना चाहूंगा, मैं यहां पर, मेरी राय में, काफी महत्वपूर्ण अनुकूलन का वर्णन करूंगा।

नीचे तुलना के लिए विभिन्न उपयोग के मामले हैं।

विकल्प 1: सामान्य

कोड	कंसोल आउटपुट
kv->get("users")--->inc();	RWMutex :: rlock मुख्य-मूल्य: कुंजी निकालना: उपयोगकर्ता RWMutex :: wlock काउंटर :: inc: 2 RWMutex :: wunlock RWMutex :: रनलॉक

विकल्प 2: इष्टतम

कोड	कंसोल आउटपुट
auto users = kv->get("users");	RWMutex :: rlock मुख्य-मूल्य: कुंजी निकालना: उपयोगकर्ता RWMutex :: रनलॉक
users--->inc();	RWMutex :: wlock काउंटर :: inc: 3 RWMutex :: wunlock

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

उदाहरण 4. परमाणु परिवर्तन के लिए समर्थन।

मान लीजिए कि हमें एटॉमिक रूप से 100 काउंटरों में से एक को बढ़ाने की आवश्यकता है, उदाहरण के लिए, "उपयोगकर्ता"। बेशक, इसके लिए आप एक ऑपरेशन को 100 बार कॉल inc()कर सकते हैं, या आप ऐसा कर सकते हैं:

कोड	कंसोल आउटपुट
auto c = kv->get("users");	RWMutex :: rlock मुख्य-मूल्य: कुंजी निकालना: उपयोगकर्ता RWMutex :: रनलॉक
KVRWType::ValueType::WAccess cw = c; cw->set(cw->get() + 100);	RWMutex :: wlock काउंटर :: प्राप्त करें: 4 काउंटर :: सेट: 104 RWMutex :: wunlock

कृपया ध्यान दें कि WAccessआगे का उपयोग करते समय , सभी ऑपरेशन सामान्य "लघु" तीर के साथ चलते हैं पहले से प्राप्त वस्तु तक पहुंच लिखें। इसके अलावा तथ्य यह है कि संचालन पर ध्यान देना getऔर setएक ही म्युटेक्स, जो है हम क्या हासिल करना चाहता था के अधीन हैं। यह इस तथ्य से बहुत मिलता-जुलता है कि हम किसी वस्तु पर कार्य करते समय लेनदेन को खोलते हैं।

एक ही चाल को सीधे काउंटरों तक पहुंचने के लिए ऊपर वर्णित अनुकूलन के साथ संयोजन में उपयोग किया जा सकता है।

विकल्प 1: सामान्य

कोड	कंसोल आउटपुट
kv->get("users")--->inc();	RWMutex :: rlock मुख्य-मूल्य: कुंजी निकालना: उपयोगकर्ता RWMutex :: wlock काउंटर :: inc: 4 RWMutex :: wunlock RWMutex :: रनलॉक
kv->get("sessions")--->dec();	RWMutex :: rlock कुंजी-मूल्य: कुंजी निकालना: सत्र RWMutex :: wlock काउंटर :: dec: -1 RWMutex :: wunlock RWMutex :: रनलॉक

विकल्प 2: इष्टतम

कोड	कंसोल आउटपुट
AnRWLock<Counter> c1, c2; { KVRWType::RAccess r = kv; c1 = r->get("users"); c2 = r->get("sessions"); }	RWMutex :: rlock मुख्य-मूल्य: कुंजी निकालना: उपयोगकर्ता कुंजी-मूल्य: कुंजी निकालना: सत्र RWMutex :: रनलॉक
c1--->inc();	RWMutex :: wlock काउंटर :: inc: 5 RWMutex :: wunlock
c2--->dec();	RWMutex :: wlock काउंटर :: डिक: -2 RWMutex :: wunlock

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

उदाहरण 5. गाय।

मान लें कि हमारे पास निम्नलिखित जानकारी वाले कर्मचारी हैं:

 struct User { std::string name; int age; double salary; //    ... }; 

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

चलो देखते हैं कि यह कैसे गाय का उपयोग करके लागू किया जा सकता है। प्रारंभिक चरण:

एक उदाहरण बनाते समय गाय का उपयोग करनाUser BIND_TO_SELF_COW(User)

हम एक नया वर्ग घोषित करते हैं जो वस्तुओं को संगृहीत कर सकता है AnCow template<typename T_key, typename T_value> struct KeyValueStorageCow : AnRWLock<KeyValueStorageImpl<T_key, AnCow<T_value>>> { };

हमारी रिपॉजिटरी की घोषणा: int- यूजर आईडी, User- यूजर KeyValueStorageCow<int, User> kv;

पीटर उपयोगकर्ता जानकारी जोड़ना AnCow<User> u; u--->name = "Peter"; u--->age = 35; u--->salary = 12345; kv--->set(1, u);

जॉर्ज उपयोगकर्ता जानकारी जोड़ना AnCow<User> u; u--->name = "George"; u--->age = 31; u--->salary = 54321; kv--->set(2, u);

कर्मचारी की उम्र संबंधी जानकारी बदलें AnCow<User> u = kv->get(2); ++ u--->age; kv--->set(2, u);

बैलेंस होल्डिंग:

सही उपयोगकर्ता प्राप्त करना AnCow<User> u1 = kv->get(1); AnCow<User> u2 = kv->get(2);

आवश्यक मापदंडों की गणना। सभी डेटा स्व-सुसंगत होंगे और संचालन के अंत तक अपरिवर्तित रहेंगे। double totalSalary = u1->salary + u2->salary; double averageSalary = totalSalary/2.; double averageAge = (u1->age + u2->age)/2.; double averageSalaryPerAge = (u1->salary/u1->age + u2->salary/u2->age)/2.; // ...

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

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

विश्लेषण और संश्लेषण

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

विस्तार से जानकारी

अंतिम उदाहरण के संचालन के अनुक्रम पर विचार करें। कंटेनर से मूल्य प्राप्त करने के लिए निम्नलिखित एक सामान्य रूपरेखा है:


यहां Data, यह Userऊपर वर्णित उदाहरण में है, और shared_ptr<Data>यह ऑब्जेक्ट की सामग्री है AnCow। संचालन का क्रम:

एन	आपरेशन	विवरण
1	ताला	भंडारण ताला, स्वचालित रूप से जब कहा जाता है operator->
2	प्रतिलिपि	कॉपी shared_ptr<Data>, यानी वास्तव में, काउंटरों में एक साधारण वृद्धि हुई है ( use_countऔर weak_countवस्तु के अंदर shared_ptr<Data>)
3	अनलॉक	अस्थायी ऑब्जेक्ट के विध्वंसक भंडारण को अनलॉक करना

इन ऑपरेशनों के बाद, आप ऑब्जेक्ट पर विभिन्न क्रियाएं कर सकते हैं। पढ़ते समय, कोई अतिरिक्त क्रिया नहीं होती है: हम बस कब्जे वाले डेटा क्षेत्र से ऑब्जेक्ट के डेटा को सीधे लेते और पढ़ते हैं। यह एक बहुत ही अप्रत्याशित बारीकियों का उल्लेख करने योग्य है: एक ताला लेने के बिना ऑब्जेक्ट डेटा पढ़ना होता है! मैं भी इस अप्रत्याशित संपत्ति पर जोर देना चाहता था जब पार्स गायन ।

किसी वस्तु को डेटा लिखते समय क्या होता है। हम देखते हैं:


इस मामले में संचालन का क्रम इस प्रकार है:

एन	आपरेशन	विवरण
4	क्लोन	किसी ऑब्जेक्ट को क्लोन करना, ऑब्जेक्ट की प्रतिलिपि बनाने वाले को कहा जाता है Data, अर्थात अपने सभी क्षेत्रों को एक नए मेमोरी क्षेत्र में कॉपी करना। इस ऑपरेशन के बाद, वह shared_ptrनव निर्मित वस्तु को देखना शुरू करता है।
5	संशोधित	. , .. .
6	ताला	.
7	replace	shared_ptr<Data> , 5- .
8	unlock	.

जैसा कि पढ़ने के मामले में, वस्तु को लिखना ताले की भागीदारी के बिना होता है , क्योंकि हम निर्मित वस्तु के एकमात्र स्वामी हैं। सिद्धांत रूप में, संचालन की एक ही योजना एक साधारण प्रकार की वस्तु के साथ जोड़तोड़ के दौरान देखी जा सकती है, उदाहरण के लिए, एक प्रकार int। महत्वपूर्ण अंतर यह है कि गाय के साथ , डेटा एक ही मेमोरी क्षेत्र से कई थ्रेड्स में एक साथ उपयोग किया जा सकता है।

यह ध्यान दिया जाना चाहिए कि उपरोक्त सभी ऑपरेशन स्वचालित रूप से होते हैं, अर्थात। स्पष्ट रूप से सभी ऑपरेशन करने की आवश्यकता नहीं है।

गाय का अनुकूलन

जैसा कि ऊपर दिखाया गया है, जब आप गाय ऑब्जेक्ट को बदलते हैं, तो उसके सभी फ़ील्ड कॉपी किए जाते हैं। कम मात्रा में डेटा के साथ यह कोई बड़ी समस्या नहीं है। लेकिन क्या होगा अगर हमारे पास कक्षा में बड़ी संख्या में पैरामीटर हैं? इस स्थिति में, आप मल्टीलेवल गाय ऑब्जेक्ट्स का उपयोग कर सकते हैं । उदाहरण के लिए, आप निम्न वर्ग में प्रवेश कर सकते हैं UserInfo:

 struct UserInfo { AnCow<AccountingInfo> accounting; AnCow<CommonInfo> common; AnCow<WorkInfo> work; }; struct AccountingInfo { AnCow<IncomingInfo> incoming; AnCow<OutcomingInfo> outcoming; AnCow<BalanceInfo> balance; }; struct CommonInfo { //  .. }; //  .. 

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

सामान्यीकृत योजना

गाय के साथ संचालन को और अधिक विस्तार से जांचने के बाद , घोंसले के शिकार को ध्यान में रखते हुए, हम अब सुरक्षित रूप से विचार किए गए मुहावरों के उपयोग को सामान्य बनाने के लिए आगे बढ़ सकते हैं। लेकिन इसके लिए, हम पहले उदाहरणों में प्रयुक्त योजनाओं पर विचार करते हैं।

पहले उदाहरण में, नेस्टेड AnRWLockऑब्जेक्ट का उपयोग किया गया था:


निर्दिष्ट उदाहरण में कुंजी-मूल्य का भंडारण एक सिंगलटन में रखा गया था और शीर्ष पर "स्मार्ट" म्यूटेक्स के साथ लिपटे थे। मान भी एक स्मार्ट म्यूटेक्स में लिपटे थे।

निम्न आरेख गाय के साथ एक उदाहरण का वर्णन करता है :


यहां, गायAnCow शब्दार्थ को लागू करने के लिए मूल्य को एक वस्तु में लपेटा गया था । तदनुसार, एक सामान्यीकृत योजना का प्रतिनिधित्व किया जा सकता है: यह स्पष्ट है कि वस्तुएं और




AnLockAn(RW)Lockविनिमेय: आप एक या दूसरे का उपयोग कर सकते हैं। तुम भी श्रृंखला showily नीचे दिए गए उदाहरण में के रूप में कई बार दोहराया जा सकता है:


हालांकि, यह याद रखना चाहिए कि वस्तुओं के अर्थ विज्ञान An(RW)Lockऔर AnCowकाफी अलग है:

संपत्ति	स्मार्ट म्यूटेक्स	गाय
ऑब्जेक्ट फ़ील्ड तक पहुंच	पढ़ते / लिखते हुए ताला लगा	अवरुद्ध नहीं है
एक कंटेनर में एक वस्तु को संशोधित करें	जगह-जगह परिवर्तन	परिवर्तन के बाद, नए मान को वापस कंटेनर में डालें

निष्कर्ष

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

1. सादगी । मल्टीथ्रेडेड प्रिमिटिव का स्पष्ट रूप से उपयोग करने की कोई आवश्यकता नहीं है, सब कुछ स्वचालित रूप से होता है।
2. . . ( ) .
3. . , (race condition) (deadlock). . (fine-grained) , .

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

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

साहित्य

[1] :
[2] :
[3] :
[4] :
[5] :
[6] :
[7] Wikipedia: Readers–writer lock
[8] :
[9] : ,
[10] : -
[11] : , C++11 [ 2]
[12] : , C++11 [ 1]
[13] :
[14] DrDobbs: Enforcing Correct Mutex Usage with Synchronized Values


— . 2 :