😕 🧞 🤫 शेअर_प्ट्र का उपयोग करते समय पांच नुकसान ⏰ 🖐🏿 ➕

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

मैं निम्नलिखित के बारे में बात करूंगा:

क्रॉस रेफरेंस क्या हैं
खतरनाक अनमोल साझा_प्रति क्या हैं;
मल्टी-थ्रेडेड वातावरण में शेयर्ड_प्ट्र का उपयोग करते समय क्या खतरे हैं;
साझा करने के लिए अपना स्वयं का रिलीज़ फ़ंक्शन बनाते समय क्या याद रखना महत्वपूर्ण है;
enable_sared_from_this टेम्पलेट का उपयोग करने की विशेषताएं क्या हैं।

वर्णित समस्याएं दोनों को बढ़ावा देने के लिए होती हैं :: share_ptr और std :: share_ptr के लिए। लेख के अंत में आपको वर्णित विशेषताओं को प्रदर्शित करने के लिए लिखे गए कार्यक्रमों के पूर्ण पाठ के साथ एक आवेदन मिलेगा (उदाहरण के लिए, बूस्ट लाइब्रेरी)।

क्रॉस संदर्भ

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

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

एक उदाहरण पर विचार करें:

struct Widget { shared_ptr<Widget> otherWidget; }; void foo() { shared_ptr<Widget> a(new Widget); shared_ptr<Widget> b(new Widget); a->otherWidget = b; //         = 2 b->otherWidget = a; //         = 2 }

क्या होता है जब वस्तुओं और बी गुंजाइश छोड़ देते हैं? विनाशकारी में वस्तुओं के संदर्भ में कमी आएगी। प्रत्येक ऑब्जेक्ट में एक काउंटर = 1 होगा (आखिरकार, अभी भी बी और बी के अंक)। ऑब्जेक्ट एक-दूसरे को "पकड़" लेते हैं और हमारे एप्लिकेशन को उन्हें एक्सेस करने का अवसर नहीं मिलता है - ये ऑब्जेक्ट "खो गए" हैं।
इस समस्या को हल करने के लिए weak_ptr है। विशिष्ट क्रॉस-रेफरेंस मामलों में से एक तब होता है जब एक ऑब्जेक्ट अन्य ऑब्जेक्ट के संग्रह का मालिक होता है।

 struct RootWidget { list<shared_ptr<class Widget> > widgets; }; struct Widget { shared_ptr<class RootWidget> parent; };

इस तरह के डिवाइस के साथ, प्रत्येक विजेट रूटविडगेट को हटाने और इसके विपरीत को रोक देगा।

इस मामले में, आपको प्रश्न का उत्तर देने की आवश्यकता है: "कौन किसका मालिक है?"। जाहिर है, यह इस मामले में रूटविजेट है जो विजेट वस्तुओं का मालिक है, और इसके विपरीत नहीं। इसलिए, आपको इस तरह के उदाहरण को संशोधित करने की आवश्यकता है:

 struct Widget { weak_ptr<class RootWidget> parent; };

कमजोर लिंक किसी वस्तु को हटाने से नहीं रोकता है। उन्हें दो तरीकों से ताकत में बदला जा सकता है:

1) कंस्ट्रक्टर शेयर्ड_प्ट्र

 weak_ptr<Widget> w = …; //  ,    ,   shared_ptr    shared_ptr<Widget> p( w );

2) ताला विधि

 weak_ptr<Widget> w = …; //  ,    ,  p    if( shared_ptr<Widget> p = w.lock() ) { //     –     }

निष्कर्ष:
आपके कोड में लूपबैक लिंक दिखाई देने की स्थिति में, समस्याओं को हल करने के लिए weak_ptr का उपयोग करें।

इशारा करते हैं

अनाम बिंदुओं की समस्या "अनुक्रम अंक" के मुद्दे को संदर्भित करती है

 // shared_ptr,     foo -  foo( shared_ptr<Widget>(new Widget), bar() ); // shared_ptr,     foo   p shared_ptr<Widget> p(new Widget); foo( p, bar() );

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

 int bar() { throw std::runtime_error(“Exception from bar()”); }

तथ्य यह है कि पहले मामले में, डिज़ाइन ऑर्डर परिभाषित नहीं है। यह सब विशेष संकलक और संकलन झंडे पर निर्भर करता है। उदाहरण के लिए, यह इस तरह हो सकता है:

नया विजेट
बार फ़ंक्शन कॉल
share_ptr निर्माण
फू फ़ंक्शन कॉल

निश्चित रूप से आप केवल यह सुनिश्चित कर सकते हैं कि फू को कॉल करना अंतिम क्रिया होगी, और शेयर_प्ट्र का निर्माण ऑब्जेक्ट (नया विजेट) बनाने के बाद किया जाएगा। हालांकि, इस बात की कोई गारंटी नहीं है कि इसका निर्माण वस्तु के निर्माण के तुरंत बाद किया जाएगा।

यदि दूसरे चरण के दौरान एक अपवाद को फेंक दिया जाता है (और इसे हमारे उदाहरण में फेंक दिया जाएगा), तो विजेट का निर्माण माना जाएगा, लेकिन साझा_प्रति अभी तक इसका मालिक नहीं होगा। परिणामस्वरूप, इस ऑब्जेक्ट का लिंक खो जाएगा। मैंने gcc 4.7.2 पर इस उदाहरण का परीक्षण किया। कॉल का क्रम ऐसा था कि साझाकरण विकल्पों की परवाह किए बिना, साझा किया गया new_ptr + नया, बार को कॉल द्वारा अलग नहीं किया गया था। लेकिन सिर्फ ऐसे व्यवहार पर भरोसा इसके लायक नहीं है - इसकी गारंटी नहीं है। मैं आभारी रहूंगा यदि वे मुझे संकलक, इसके संस्करण और संकलन विकल्प बताते हैं जिसके लिए इस तरह के कोड में त्रुटि होगी।

अनाम शेयर्ड_पार्ट समस्या के इर्द-गिर्द एक और तरीका है मेक_शेयर या आबंटित_सक्रिय कार्य का उपयोग करना। हमारे उदाहरण के लिए, यह इस तरह दिखेगा:

 foo( make_shared<Widget>(), bar() );

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

 make_shared<string>("shared string");

निष्कर्ष:
भले ही कोड इस से कम संक्षिप्त है, या वस्तुओं को बनाने के लिए उपयोग करने के लिए साझा करें
make_sared और आवंटित करें_शराब कार्य करता है।

विभिन्न थ्रेड्स में उपयोग करने की समस्या

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

मान लें कि हमारे पास एक वैश्विक साझा_प्रीत है:

 shared_ptr<Widget> globalSharedPtr(new Widget); void read() { shared_ptr<Widget> x = globalSharedPtr; //  -  Widget }

विभिन्न थ्रेड्स से रीड कॉल को चलाएं और आप देखेंगे कि कोड में कोई समस्या नहीं है (जब तक आप विजेट पर इस वर्ग के लिए थ्रेड-सुरक्षित संचालन करते हैं)।

मान लीजिए कि एक और समारोह है:

 void write() { globalSharedPtr.reset( new Widget ); }

Share_ptr डिवाइस काफी जटिल है, इसलिए मैं एक कोड दूंगा जो योजनाबद्ध रूप से समस्या को दिखाने में मदद करता है। बेशक, यह कोड अलग दिखता है।

 shared_ptr::shared_ptr(const shared_ptr<T>& x) { A1: pointer = x.pointer; A2: counter = x.counter; A3: atomic_increment( *counter ); } shared_ptr<T>::reset(T* newObject) { B1: if( atomic_decrement( *counter ) == 0 ) { B2: delete pointer; B3: delete counter; B4: } B5: pointer = newObject; B6: counter = new Counter; }

मान लें कि पहला थ्रेड GlobalSaringPtr (पढ़ा) की प्रतिलिपि बनाना शुरू कर देता है, और दूसरा थ्रेड कॉल उसी पॉइंटर उदाहरण (लिखने) के लिए रीसेट हो जाता है। परिणाम निम्नलिखित हो सकता है:

थ्रेड 1 ने लाइन ए 2 को पूरा कर लिया है, लेकिन अभी तक ए 3 (परमाणु वेतन वृद्धि) को स्थानांतरित नहीं किया है।
स्ट्रीम 2 ने इस समय लाइन बी 1 पर काउंटर को कम कर दिया, देखा कि घटने के बाद काउंटर शून्य हो गया और लाइनों बी 2 और बी 3 को पूरा किया।
थ्रेड 1 लाइन ए 3 तक पहुंचता है और काउंटर को परमाणु रूप से बढ़ाने की कोशिश करता है, जो पहले से ही चला गया है।

या यह हो सकता है कि धारा 2 पर स्ट्रीम 1 में काउंटर को बढ़ाने का समय है क्योंकि स्ट्रीम 2 से पहले ऑब्जेक्ट हटा दिए जाते हैं, लेकिन स्ट्रीम 2 की गिनती होने के बाद। तब हमें रिमोट काउंटर और ऑब्जेक्ट की ओर इशारा करते हुए एक नया शेयर्ड_एप्ट मिलता है।

आप समान कोड लिख सकते हैं:

 shared_ptr<Widget> globalSharedPtr(new Widget); mutex_t globalSharedPtrMutex; void resetGlobal(Widget* x) { write_lock_t l(globalSharedPtrMutex); globalSharedPtr.reset( x ); } shared_ptr<Widget> getGlobal() { read_lock_t l(globalSharedPtrMutex); return globalSharedPtr; } void read() { shared_ptr<Widget> x = getGlobal(); //    x    } void write() { resetGlobal( new Widget ); }

अब, इस तरह के कार्यों का उपयोग करके, आप सुरक्षित रूप से इस साझा_प्ट्र के साथ काम कर सकते हैं।

निष्कर्ष: यदि कुछ साझा_पार्ट इंस्टेंस अलग-अलग थ्रेड्स के लिए उपलब्ध है और इसे संशोधित किया जा सकता है, तो आपको इस शेयर्ड_पार्ट इंस्टेंस तक पहुँच को सिंक्रनाइज़ करने का ध्यान रखना होगा।

Share_ptr के लिए रिलीज़ फ़ाइटर के विनाश समय की ख़ासियत

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

 typedef shared_ptr<Connection> ptr_t; class ConnectionReleaser { list<ptr_t>& whereToReturn; ptr_t connectionToRelease; public: ConnectionReleaser(list<ptr_t>& lst, const ptr_t& x):whereToReturn(lst), connectionToRelease(x) {} void operator()(Connection*) { whereToReturn.push_back( connectionToRelease ); //      connectionToRelease.reset(); } }; ptr_t getConnection() { ptr_t c( connectionList.back() ); connectionList.pop_back(); ptr_t r( c.get(), ConnectionReleaser( connectionList, c ) ); return r; }

समस्या यह है कि साझा किए गए फ़न्तेकार के लिए जारी किए गए ऑब्जेक्ट को share_ptr के लिए ही नष्ट कर दिया जाएगा, जब ऑब्जेक्ट के सभी संदर्भ नष्ट हो जाएंगे - दोनों मजबूत (साझा_प्रति) और कमजोर (weak_ptr)। इस प्रकार, अगर ConnectionReleaser पॉइंटर को "रिलीज़" करने के लिए ध्यान नहीं देता है, तो इसके पास (कनेक्शनटॉइलेज़) को पास किया जाता है, यह तब तक एक मजबूत लिंक रखेगा, जब तक कि getConnection फ़ंक्शन द्वारा बनाए गए साझा_ptr से कम से कम एक कमजोर_परटर होता है। इससे आपके आवेदन का काफी अप्रिय और अप्रत्याशित व्यवहार हो सकता है।

यह भी संभव है कि आप बाइंड का उपयोग रिलीज़ फ़िक्सर बनाने के लिए करें। उदाहरण के लिए, इस तरह:

 void releaseConnection(std::list<ptr_t>& whereToReturn, ptr_t& connectionToRelease) { whereToReturn.push_back( connectionToRelease ); //      connectionToRelease.reset(); } ptr_t getConnection() { ptr_t c( connectionList.back() ); connectionList.pop_back(); ptr_t r( c.get(), boost::bind(&releaseConnection, boost::ref(connectionList), c) ); return r; }

याद रखें कि इसे पास किए गए तर्कों को कॉपी करता है (बढ़ावा देने के लिए मामले के अलावा :: रेफरी), और यदि उनके बीच share_ptr है, तो पहले से वर्णित समस्या से बचने के लिए इसे भी साफ़ किया जाना चाहिए।

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

Enable_sared_from_this टेम्पलेट के साथ काम करने की सुविधाएँ

कभी-कभी आपको ऑब्जेक्ट के तरीकों से साझा करने की आवश्यकता होती है। इस से एक नया साझा_पाठ बनाने का प्रयास करने से घुसपैठ व्यवहार (कार्यक्रम के दुर्घटनाग्रस्त होने की संभावना), घुसपैठ_पर के विपरीत होगा, जिसके लिए यह आम बात है। इस समस्या को हल करने के लिए, एक टेम्पलेट प्रवेश कक्षा में enable_sared_from_this का आविष्कार किया गया था।

Enable_sared_from_this टेम्पलेट को निम्नानुसार संरचित किया गया है: वर्ग में कमजोर_प्रति है, जो साझा करने के लिए साझा करता है, जिसमें यह साझा करने के लिए एक संदर्भ होता है। जब ऑब्जेक्ट के शेयर्ड_फॉम_थिस विधि को कॉल किया जाता है, तो कमजोर_प्ट्र कंस्ट्रक्टर के माध्यम से शेयर्ड_प्ट्र में बदल जाता है। योजनाबद्ध रूप से, टेम्पलेट इस तरह दिखता है:

 template<class T> class enable_shared_from_this { weak_ptr<T> weak_this_; public: shared_ptr<T> shared_from_this() { //        shared_ptr shared_ptr<T> p( weak_this_ ); return p; } }; class Widget: public enable_shared_from_this<Widget> {};

इस मामले के लिए share_ptr कंस्ट्रक्टर इस तरह दिखता है:

 shared_ptr::shared_ptr(T* object) { pointer = object; counter = new Counter; object->weak_this_ = *this; }

यह समझना महत्वपूर्ण है कि किसी वस्तु का निर्माण करते समय कमजोर_थिस_ अभी भी कुछ भी इंगित नहीं करता है। निर्माण किए गए ऑब्जेक्ट को share_ptr कंस्ट्रक्टर को पास करने के बाद ही सही लिंक इसमें दिखाई देगा। कंस्ट्रक्टर से साझा_फ्रेम_थिस को कॉल करने का कोई भी प्रयास खराब_वाक_प्रति अपवाद को फेंक देगा।

 struct BadWidget: public enable_shared_from_this<BadWidget> { BadWidget() { //   shared_from_this()   bad_weak_ptr cout << shared_from_this() << endl; } };

विध्वंसक से साझा_फ्रेम_थिस तक पहुंचने का प्रयास एक ही परिणाम देगा, लेकिन एक अलग कारण के लिए: ऑब्जेक्ट के विनाश के समय, यह पहले से ही माना जाता है कि कोई मजबूत लिंक इसे इंगित नहीं करता है (काउंटर डीक्रिएट किया गया है)।

 struct BadWidget: public enable_shared_from_this<BadWidget> { ~BadWidget() { //   shared_from_this()   bad_weak_ptr cout << shared_from_this() << endl; } };

दूसरे मामले (विध्वंसक) के साथ, थोड़ा सोचा जा सकता है। एकमात्र विकल्प ध्यान रखना है कि साझा किए गए_फ्रेम_थिस को कॉल न करें और सुनिश्चित करें कि विध्वंसक कॉल नहीं करते हैं।

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

 class GoodWidget: public enable_shared_from_this<GoodWidget> { void init() { cout << shared_from_this() << endl; } public: static shared_ptr<GoodWidget> create() { shared_ptr<GoodWidget> p(new GoodWidget); p->init(); return p; } };

निष्कर्ष:
कंस्ट्रक्टर और डिस्ट्रक्टर्स से कॉलिंग (प्रत्यक्ष या अप्रत्यक्ष) साझा_फ्रेम_थिस से बचें। यदि ऑब्जेक्ट के उचित आरंभीकरण के लिए साझा_फ्रेम_थिस तक पहुँच की आवश्यकता होती है: init मेथड बनाएँ, ऑब्जेक्ट के निर्माण को स्टैटिक मेथड में डेलिगेट करें और इसे बनाएं ताकि ऑब्जेक्ट्स केवल इस पद्धति का उपयोग करके बनाया जा सके।

निष्कर्ष

आलेख साझा_प्रति का उपयोग करने की 5 विशेषताओं पर चर्चा करता है और संभावित समस्याओं से बचने के लिए सामान्य सिफारिशें प्रदान करता है।

हालाँकि शेयर्ड_एप्ट्र डेवलपर से बहुत सारी समस्याओं को दूर करता है, शेर्ल_प्ट्र के समुचित उपयोग के लिए आंतरिक डिवाइस (लगभग) का ज्ञान अनिवार्य है। मेरा सुझाव है कि आप साझा किए गए डिवाइस, साथ ही साथ इससे जुड़ी कक्षाओं का सावधानीपूर्वक अध्ययन करें। कई सरल नियमों का अनुपालन डेवलपर को अवांछित समस्याओं से बचा सकता है।

साहित्य

Boost.org प्रलेखन
स्कॉट Meyers "और अधिक प्रभावी सी ++: 35 नए तरीके अपने कार्यक्रमों और डिजाइनों में सुधार करने के लिए"

आवेदन

परिशिष्ट में लेख में वर्णित मामलों को चित्रित करने के लिए कार्यक्रमों के पूर्ण पाठ शामिल हैं।

रिंग लिंक जारी करना प्रदर्शन

 #include <string> #include <iostream> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> class BadWidget { std::string name; boost::shared_ptr<BadWidget> otherWidget; public: BadWidget(const std::string& n):name(n) { std::cout << "BadWidget " << name << std::endl; } ~BadWidget() { std::cout << "~BadWidget " << name << std::endl; } void setOther(const boost::shared_ptr<BadWidget>& x) { otherWidget = x; std::cout << name << " now points to " << x->name << std::endl; } }; class GoodWidget { std::string name; boost::weak_ptr<GoodWidget> otherWidget; public: GoodWidget(const std::string& n):name(n) { std::cout << "GoodWidget " << name << std::endl; } ~GoodWidget() { std::cout << "~GoodWidget " << name << std::endl; } void setOther(const boost::shared_ptr<GoodWidget>& x) { otherWidget = x; std::cout << name << " now points to " << x->name << std::endl; } }; int main() { { //       std::cout << "====== Example 3" << std::endl; boost::shared_ptr<BadWidget> w1(new BadWidget("3_First")); boost::shared_ptr<BadWidget> w2(new BadWidget("3_Second")); w1->setOther( w2 ); w2->setOther( w1 ); } { //      weak_ptr      std::cout << "====== Example 3" << std::endl; boost::shared_ptr<GoodWidget> w1(new GoodWidget("4_First")); boost::shared_ptr<GoodWidget> w2(new GoodWidget("4_Second")); w1->setOther( w2 ); w2->setOther( w1 ); } return 0; }

कमजोर_प्रति को साझा_प्रति में परिवर्तित करने का प्रदर्शन

 #include <iostream> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> class Widget {}; int main() { boost::weak_ptr<Widget> w; //    weak_ptr      //  lock    std::cout << __LINE__ << ": " << w.lock().get() << std::endl; //  shared_ptr       try { boost::shared_ptr<Widget> tmp ( w ); } catch (const boost::bad_weak_ptr&) { std::cout << __LINE__ << ": bad_weak_ptr" << std::endl; } boost::shared_ptr<Widget> p(new Widget); //   weak_ptr   w = p; //  lock    std::cout << __LINE__ << ": " << w.lock().get() << std::endl; //  shared_ptr       .    std::cout << __LINE__ << ": " << boost::shared_ptr<Widget>( w ).get() << std::endl; //   p.reset(); //    .  weak_ptr    //  lock     std::cout << __LINE__ << ": " << w.lock().get() << std::endl; //  shared_ptr        try { boost::shared_ptr<Widget> tmp ( w ); } catch (const boost::bad_weak_ptr&) { std::cout << __LINE__ << ": bad_weak_ptr" << std::endl; } return 0; }

Share_ptr के लिए मल्टीथ्रेडिंग समस्या का प्रदर्शन

 #include <iostream> #include <boost/thread.hpp> #include <boost/shared_ptr.hpp> typedef boost::shared_mutex mutex_t; typedef boost::unique_lock<mutex_t> read_lock_t; typedef boost::shared_lock<mutex_t> write_lock_t; mutex_t globalMutex; boost::shared_ptr<int> globalPtr(new int(0)); const int readThreads = 10; const int maxOperations = 10000; boost::shared_ptr<int> getPtr() { //   ,     read_lock_t l(globalMutex); return globalPtr; } void resetPtr(const boost::shared_ptr<int>& x) { //   ,     write_lock_t l(globalMutex); globalPtr = x; } void myRead() { for(int i = 0; i < maxOperations; ++i) { boost::shared_ptr<int> p = getPtr(); } } void myWrite() { for(int i = 0; i < maxOperations; ++i) { resetPtr( boost::shared_ptr<int>( new int(i)) ); } } int main() { boost::thread_group tg; tg.create_thread( &myWrite ); for(int i = 0; i < readThreads; ++i) { tg.create_thread( &myRead ); } tg.join_all(); return 0; }

डिलेटर + कमजोर_प्रति समस्या का प्रदर्शन

 #include <string> #include <list> #include <iostream> #include <stdexcept> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> #include <boost/bind.hpp> class Connection { std::string name; public: const std::string& getName() const { return name; } explicit Connection(const std::string& n):name(n) { std::cout << "Connection " << name << std::endl; } ~Connection() { std::cout << "~Connection " << name << std::endl; } }; typedef boost::shared_ptr<Connection> ptr_t; class ConnectionPool { std::list<ptr_t> connections; //         deleter (get1) class ConnectionReleaser { std::list<ptr_t>& whereToReturn; ptr_t connectionToRelease; public: ConnectionReleaser(std::list<ptr_t>& lst, const ptr_t& x):whereToReturn(lst), connectionToRelease(x) {} void operator()(Connection*) { whereToReturn.push_back( connectionToRelease ); std::cout << "get1: Returned connection " << connectionToRelease->getName() << " to the list" << std::endl; //  .          connectionToRelease.reset(); } }; //         deleter (get2) static void releaseConnection(std::list<ptr_t>& whereToReturn, ptr_t& connectionToRelease) { whereToReturn.push_back( connectionToRelease ); std::cout << "get2: Returned connection " << connectionToRelease->getName() << " to the list" << std::endl; //            connectionToRelease.reset(); } ptr_t popConnection() { if( connections.empty() ) throw std::runtime_error("No connections left"); ptr_t w( connections.back() ); connections.pop_back(); return w; } public: ptr_t get1() { ptr_t w = popConnection(); std::cout << "get1: Taken connection " << w->getName() << " from list" << std::endl; ptr_t r( w.get(), ConnectionReleaser( connections, w ) ); return r; } ptr_t get2() { ptr_t w = popConnection(); std::cout << "get2: Taken connection " << w->getName() << " from list" << std::endl; ptr_t r( w.get(), boost::bind(&releaseConnection, boost::ref(connections), w )); return r; } void add(const std::string& name) { connections.push_back( ptr_t(new Connection(name)) ); } ConnectionPool() { std::cout << "ConnectionPool" << std::endl; } ~ConnectionPool() { std::cout << "~ConnectionPool" << std::endl; } }; int main() { boost::weak_ptr<Connection> weak1; boost::weak_ptr<Connection> weak2; { ConnectionPool cp; cp.add("One"); cp.add("Two"); ptr_t p1 = cp.get1(); weak1 = p1; ptr_t p2 = cp.get2(); weak2 = p2; } std::cout << "Here the ConnectionPool is out of scope, but weak_ptrs are not" << std::endl; return 0; }

Enable_sared_from_this के साथ समस्या का प्रदर्शन

 #include <iostream> #include <boost/shared_ptr.hpp> #include <boost/enable_shared_from_this.hpp> class BadWidget1: public boost::enable_shared_from_this<BadWidget1> { public: BadWidget1() { std::cout << "Constructor" << std::endl; std::cout << shared_from_this() << std::endl; } }; class BadWidget2: public boost::enable_shared_from_this<BadWidget2> { public: ~BadWidget2() { std::cout << "Destructor" << std::endl; std::cout << shared_from_this() << std::endl; } }; class GoodWidget: public boost::enable_shared_from_this<GoodWidget> { GoodWidget() {} void init() { std::cout << "init()" << std::endl; std::cout << shared_from_this() << std::endl; } public: static boost::shared_ptr<GoodWidget> create() { boost::shared_ptr<GoodWidget> p(new GoodWidget); p->init(); return p; } }; int main() { boost::shared_ptr<GoodWidget> good = GoodWidget::create(); try { boost::shared_ptr<BadWidget1> bad1(new BadWidget1); } catch( const boost::bad_weak_ptr&) { std::cout << "Caught bad_weak_ptr for BadWidget1" << std::endl; } try { boost::shared_ptr<BadWidget2> bad2(new BadWidget2); //        terminate // .. ,           } catch( const boost::bad_weak_ptr&) { std::cout << "Caught bad_weak_ptr for BadWidget2" << std::endl; } return 0; }

शेअर_प्ट्र का उपयोग करते समय पांच नुकसान