🙎🏿 👨‍🎓 👩🏾‍🤝‍👨🏽 C ++ (अभ्यास) में बहुपरत पर्यवेक्षक 🎨 🍢 🤱🏼

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

इस लेख में मैं बहु-थ्रेडेड अनुप्रयोगों में पैटर्न को लागू करने के अनुभव को साझा करना चाहता हूं और मुख्य समस्याओं का वर्णन करता हूं जो मुझे सामना करना पड़ा है।

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

यदि आपको तैयार समाधान की आवश्यकता है, तो सिग्नल 2 लाइब्रेरी पर ध्यान दें, जिसे मई 2009 से बढ़ावा दिया गया है।

मैं एक ऐसा समाधान प्रदान करने की कोशिश नहीं कर रहा हूं जिसका उपयोग तैयार किया जा सके। फिर भी, सामग्री को पढ़ने के बाद, आप उन परियोजनाओं में तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना कर सकते हैं, जिनमें वे उपलब्ध नहीं हैं या किसी कारण (ड्राइवर, निम्न-स्तरीय अनुप्रयोगों, आदि) के लिए अवांछनीय हैं।

विषय क्षेत्र

पात्र

सूचना भेजने वाला - संदेश भेजने वाली वस्तु।

आमतौर पर, यह अपने राज्य में परिवर्तन की घोषणा करने वाला एक वर्कफ़्लो है, जिसे उपयोगकर्ता इंटरफ़ेस पर प्रदर्शित किया जाना चाहिए।

NotificationListener - एक ऑब्जेक्ट जो अधिसूचना प्रसंस्करण को लागू करता है।

आमतौर पर, यह एक ऑब्जेक्ट है जो पृष्ठभूमि कार्य से जुड़े उपयोगकर्ता इंटरफ़ेस के एक हिस्से के प्रदर्शन को नियंत्रित करता है।

ऐसी कई वस्तुएं हो सकती हैं, जबकि वे गतिशील रूप से कनेक्ट / डिस्कनेक्ट की जा सकती हैं (उदाहरण के लिए, एक संवाद बॉक्स खोलना जहां कार्य का विवरण दिखाया गया है)

NotificationDispatcher - एक वस्तु जो ग्राहकों और मेलिंग सूचियों का प्रबंधन करती है।

वस्तुओं के बीच बातचीत

सभी ग्राहकों को संदेशों का वितरण।

किसी सदस्यता को समाप्त / समाप्त करने की प्रक्रिया।

वस्तुओं का जीवनकाल।

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

सबसे सरल एकल-थ्रेडेड कार्यान्वयन

typedef unsigned __int64 SubscriberId; class CSubscriber { public: virtual ~CSubscriber(){} virtual void MessageHandler(void* pContext) = 0; SubscriberId GetSubscriberId() {return (SubscriberId)this;} }; class CDispatcher { private: typedef std::vector<CSubscriber*> CSubscriberList; public: SubscriberId Subscribe(CSubscriber* pNewSubscriber) { for(size_t i = 0; i < m_SubscriberList.size(); ++i) { if(m_SubscriberList[i]->GetSubscriberId() == pNewSubscriber->GetSubscriberId()) { return 0; } } m_SubscriberList.push_back(pNewSubscriber); return pNewSubscriber->GetSubscriberId(); } bool Unsubscribe(SubscriberId id) { for(size_t i = 0; i < m_SubscriberList.size(); ++i) { if(m_SubscriberList[i]->GetSubscriberId() == id) { m_SubscriberList.erase(m_SubscriberList.begin() + i); return true; } } return false; } void SendMessage(void* pContext) { for(size_t i = 0; i < m_SubscriberList.size(); ++i) { m_SubscriberList[i]->MessageHandler(pContext); } } private: CSubscriberList m_SubscriberList; };

यहां ग्राहक की विशिष्ट पहचान ग्राहक वस्तु का पता है, GetSubscriberId फ़ंक्शन हमेशा एक ग्राहक वस्तु के लिए समान मान लौटाता है, चाहे वह किसी भी प्रकार का हो।

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

 class CListener: public CSubscriber { virtual void MessageHandler(void* pContext) { wprintf(L"%d\n", *((int*)pContext)); } }; int _tmain(int argc, _TCHAR* argv[]) { CDispatcher Dispatcher; CListener Listener1; CListener Listener2; Dispatcher.Subscribe(&Listener1); Dispatcher.Subscribe(&Listener2); for(int i = 0; i < 5; ++i) { Dispatcher.SendMessage(&i); } Dispatcher.Unsubscribe(Listener2.GetSubscriberId()); Dispatcher.Unsubscribe(Listener1.GetSubscriberId()); return 0; }

एक संदेश हैंडलर के अंदर एक सब्सक्राइबर को अक्षम करना

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

एक बहुआयामी वातावरण में आगे बढ़ रहा है

एक धागे के साथ, ऐसा कोड काफी काम करेगा।

आइए देखें कि जब कई धागे काम करते हैं तो क्या होता है।

 CDispatcher g_Dispatcher; DWORD WINAPI WorkingThread(PVOID pParam) { for(int i = 0;;++i) { g_Dispatcher.SendMessage(&i); } }; int _tmain(int argc, _TCHAR* argv[]) { ::CreateThread(NULL, 0, WorkingThread, NULL, 0, NULL); CListener Listener1; CListener Listener2; for(;;) { g_Dispatcher.Subscribe(&Listener1); g_Dispatcher.Subscribe(&Listener2); g_Dispatcher.Unsubscribe(Listener1.GetSubscriberId()); g_Dispatcher.Unsubscribe(Listener2.GetSubscriberId()); } return 0; }

जल्दी या बाद में, एक दुर्घटना घटित होगी।

समस्या ग्राहकों को जोड़ रही है / हटा रही है और एक ही समय में नोटिफिकेशन भेज रही है (हमारे उदाहरण में CDispatcher :: m_SubscriberList पर बहु-थ्रेडेड एक्सेस)।

यहां आपको ग्राहकों की सूची तक पहुंच को सिंक्रनाइज़ करने की आवश्यकता है।

सब्सक्राइबर सूची एक्सेस सिंक्रोनाइज़ेशन

 class CDispatcher { private: typedef std::vector<CSubscriber*> CSubscriberList; public: SubscriberId Subscribe(CSubscriber* pNewSubscriber) { CScopeLocker ScopeLocker(m_Lock); for(size_t i = 0; i < m_SubscriberList.size(); ++i) { if(m_SubscriberList[i]->GetSubscriberId() == pNewSubscriber->GetSubscriberId()) { return 0; } } m_SubscriberList.push_back(pNewSubscriber); return pNewSubscriber->GetSubscriberId(); } bool Unsubscribe(SubscriberId id) { CScopeLocker ScopeLocker(m_Lock); for(size_t i = 0; i < m_SubscriberList.size(); ++i) { if(m_SubscriberList[i]->GetSubscriberId() == id) { m_SubscriberList.erase(m_SubscriberList.begin() + i); return true; } } return false; } void SendMessage(void* pContext) { CScopeLocker ScopeLocker(m_Lock); for(size_t i = 0; i < m_SubscriberList.size(); ++i) { m_SubscriberList[i]->MessageHandler(pContext); } } private: CSubscriberList m_SubscriberList; CLock m_Lock; };

एक्सेस सिंक्रोनाइज़ेशन को सिंक्रोनाइज़ेशन ऑब्जेक्ट्स (क्रिटिकल सेक्शन या म्यूटेक्स) का उपयोग करके लागू किया गया था।

अधिक पोर्टेबिलिटी के लिए और जो कुछ हो रहा है, उसके सार से विचलित नहीं होने के लिए, हम सीधे कॉल से लेकर प्लेटफॉर्म-डिपेंडेंट फंक्शन्स जैसे कि एंटरक्रिटलीसेक्शन पर अमल करते हैं। ऐसा करने के लिए, CLock वर्ग का उपयोग करें।

C ++ अपवादों के प्रतिरोध के लिए, RAII तकनीक का उपयोग करना सुविधाजनक है, अर्थात् CScopeLocker वर्ग, जो कंस्ट्रक्टर में एक सिंक्रनाइज़ेशन ऑब्जेक्ट को पकड़ता है और इसे विध्वंसक में मुक्त करता है।

इस तरह के कार्यान्वयन से, कार्यक्रम गिर नहीं जाएगा, लेकिन एक और अप्रिय स्थिति हमें इंतजार कर रही है।

गतिरोध से लड़ना

मान लीजिए कि हमारे पास एक निश्चित धागा है जो कुछ पृष्ठभूमि कार्य करता है और एक खिड़की है जहां इस कार्य की प्रगति प्रदर्शित होती है।

आमतौर पर, एक थ्रेड विंडो क्लास को एक अधिसूचना भेजता है, जो बदले में SendMessage सिस्टम फ़ंक्शन को कॉल करता है, जो विंडो प्रक्रिया के संदर्भ में कुछ कार्रवाई शुरू करता है।

SendMessage सिस्टम फ़ंक्शन अवरुद्ध है, यह विंडो थ्रेड के लिए एक संदेश भेजता है और इसे संसाधित करने के लिए प्रतीक्षा करता है।

यदि श्रोता वस्तु का कनेक्शन / वियोग विंडो प्रक्रिया (विंडो थ्रेड में), थ्रेड्स के आपसी अवरोधन, तथाकथित गतिरोध के संदर्भ में भी होगा, तो संभव है।

इस तरह के गतिरोध को शायद ही कभी पुन: प्रस्तुत किया जा सकता है (कॉलिंग के समय सदस्यता लें / सदस्यता समाप्त करें और एक ही समय में MessageHandler को अलग थ्रेड में बुलाएं)

निम्न कोड SendMessage सिस्टम फ़ंक्शन के लिए एक अवरुद्ध कॉल का अनुकरण करता है।

 CDispatcher g_Dispatcher; CLock g_Lock; class CListener: public CSubscriber { virtual void MessageHandler(void* pContext) { //   SendMessage g_Lock.Lock(); wprintf(L"%d\n", *((int*)pContext)); g_Lock.Unlock(); } }; DWORD WINAPI WorkingThread(PVOID pParam) { for(int i = 0;;++i) { g_Dispatcher.SendMessage(&i); } }; int _tmain(int argc, _TCHAR* argv[]) { ::CreateThread(NULL, 0, WorkingThread, NULL, 0, NULL); CListener Listener1; CListener Listener2; for(;;) { //    (  ) g_Lock.Lock(); g_Dispatcher.Subscribe(&Listener1); g_Dispatcher.Subscribe(&Listener2); g_Lock.Unlock(); Sleep(0); g_Lock.Lock(); g_Dispatcher.Unsubscribe(Listener1.GetSubscriberId()); g_Dispatcher.Unsubscribe(Listener2.GetSubscriberId()); g_Lock.Unlock(); } return 0; }

समस्या यह है कि मुख्य थ्रेड g_Lock ग्लोबल सिंक्रोनाइज़ेशन ऑब्जेक्ट (विंडो प्रक्रिया के अनुरूप होने पर, यह विंडो स्ट्रीम के संदर्भ में निष्पादित होता है) को कैप्चर करता है, और फिर Subscribe / Unsubscribe मेथड को कॉल करता है, जिसके अंदर दूसरा CDispatcher :: m_Lock सिंक्रोनाइज़ेशन ऑब्जेक्ट कैप्चर करने का प्रयास करता है।

इस समय, वर्कर थ्रेड एक सूचना भेजता है, CDispatcher :: m_Lock in CDispatcher :: SendMessage फ़ंक्शन को कैप्चर करता है, और फिर g_Lock ग्लोबल सिंक्रोनाइज़ेशन ऑब्जेक्ट (विंडो के साथ सादृश्य में, यह SendMessage सिस्टम फ़ंक्शन को कॉल करता है) को कैप्चर करने का प्रयास करता है।

 विंडो फ्लो ए -> बी
 वर्कफ़्लो बी -> ए

इसे क्लासिक गतिरोध कहा जा सकता है।

समस्या CDispatcher :: SendMessage () फ़ंक्शन में निहित है।

यहां नियम का पालन किया जाना चाहिए - आप किसी भी सिंक्रनाइज़ेशन ऑब्जेक्ट को कैप्चर करते समय कॉलबैक फ़ंक्शन को कॉल नहीं कर सकते।

इसलिए, हम सूचनाएँ भेजते समय ताला हटा देते हैं।

 void SendMessage(void* pContext) { CSubscriberList SubscriberList; { CScopeLocker ScopeLocker(m_Lock); SubscriberList = m_SubscriberList; } for(size_t i = 0; i < SubscriberList.size(); ++i) { SubscriberList[i]->MessageHandler(pContext); } }

आजीवन नियंत्रण की सदस्यता लेता है

डेडलॉक हटाने के बाद, एक और समस्या सामने आई - वस्तुओं की सदस्यता का जीवनकाल।

अब हमारे पास यह गारंटी नहीं है कि Unsubscribe को कॉल करने के बाद MessageHandler विधि को कॉल नहीं किया जाएगा, और इसलिए हम Unsubscribe को कॉल करने के तुरंत बाद सब्स्क्राइब्ड ऑब्जेक्ट को हटा नहीं सकते।

इस स्थिति में, लिंक काउंटर का उपयोग करके वस्तुओं की सदस्यता के जीवनकाल को नियंत्रित करने का सबसे आसान तरीका है।

ऐसा करने के लिए, आप COM तकनीक का उपयोग कर सकते हैं - IUnogn से CSubscriber इंटरफ़ेस वारिस करें और ऑब्जेक्ट्स की सदस्यता की सूची के लिए ATL CComPtr का उपयोग करें, यानी std :: वेक्टर <CSubscriber *> std :: वेक्टर <CComPtr> की जगह लें।

लेकिन इस तरह के एक कार्यान्वयन ग्राहक वर्गों के कार्यान्वयन के लिए अतिरिक्त लागतों से भरा हुआ है, क्योंकि उनमें से प्रत्येक में AddRef / Release और अनावश्यक QueryInterface विधियों को लागू किया जाना चाहिए, हालांकि यदि परियोजना COM का सक्रिय रूप से उपयोग कर रही है, तो इस दृष्टिकोण का एक फायदा हो सकता है।

स्मार्ट पॉइंटर्स लिंक काउंटर का उपयोग करके वस्तुओं की सदस्यता के जीवनकाल को नियंत्रित करने के लिए अच्छी तरह से अनुकूल हैं।

बहु-थ्रेडेड वातावरण के लिए सरल कार्यान्वयन

 typedef unsigned __int64 SubscriberId; class CSubscriber { public: virtual ~CSubscriber(){} virtual void MessageHandler(void* pContext) = 0; SubscriberId GetSubscriberId() {return (SubscriberId)this;} }; typedef boost::shared_ptr<CSubscriber> CSubscriberPtr; class CDispatcher { private: typedef std::vector<CSubscriberPtr> CSubscriberList; public: SubscriberId Subscribe(CSubscriberPtr pNewSubscriber) { CScopeLocker ScopeLocker(m_Lock); for(size_t i = 0; i < m_SubscriberList.size(); ++i) { if(m_SubscriberList[i]->GetSubscriberId() == pNewSubscriber->GetSubscriberId()) { return 0; } } m_SubscriberList.push_back(pNewSubscriber); return pNewSubscriber->GetSubscriberId(); } bool Unsubscribe(SubscriberId id) { CSubscriberPtr toRelease; CScopeLocker ScopeLocker(m_Lock); for(size_t i = 0; i < m_SubscriberList.size(); ++i) { if(m_SubscriberList[i]->GetSubscriberId() == id) { toRelease = m_SubscriberList[i]; m_SubscriberList.erase(m_SubscriberList.begin() + i); return true; } } return false; } void SendMessage(void* pContext) { CSubscriberList SubscriberList; { CScopeLocker ScopeLocker(m_Lock); SubscriberList = m_SubscriberList; } for(size_t i = 0; i < SubscriberList.size(); ++i) { SubscriberList[i]->MessageHandler(pContext); } } private: CSubscriberList m_SubscriberList; CLock m_Lock; };

इस कार्यान्वयन में, मैंने एक संदर्भ काउंटर के साथ "स्मार्ट" सूचक के साथ "नंगे" CSubscriber के पॉइंटर को बदल दिया, जो बूस्ट लाइब्रेरी में निकला।

साथ ही, मैंने अनलॉक के बाद सब्सक्राइबर ऑब्जेक्ट के डिस्ट्रक्टर को कॉल करने के लिए अनसब्सक्राइब फ़ंक्शन में toRelease वैरिएबल को जोड़ा (आप अपने सिंक्रोनाइज़ेशन ऑब्जेक्ट को कैप्चर करते समय सब्सक्राइबर ऑब्जेक्ट के डिस्ट्रक्टर सहित कॉलबैक फ़ंक्शन को कॉल नहीं कर सकते हैं)।

यह ध्यान देने योग्य है कि SendMessage फ़ंक्शन स्मार्ट पॉइंटर्स की सूची की प्रतिलिपि बनाता है (कॉपी करने के बाद, सभी पॉइंटर्स उनके संदर्भ की संख्या में वृद्धि करते हैं, और जब वे फ़ंक्शन से बाहर निकलते हैं, तो वे घट जाते हैं, जो वस्तुओं की सदस्यता के जीवनकाल को नियंत्रित करता है)

परीक्षण

 CDispatcher g_Dispatcher; CLock g_Lock; class CListener: public CSubscriber { virtual void MessageHandler(void* pContext) { //   SendMessage g_Lock.Lock(); wprintf(L"%d\n", *((int*)pContext)); g_Lock.Unlock(); } }; DWORD WINAPI WorkingThread(PVOID pParam) { for(int i = 0;;++i) { g_Dispatcher.SendMessage(&i); } }; int _tmain(int argc, _TCHAR* argv[]) { ::CreateThread(NULL, 0, WorkingThread, NULL, 0, NULL); for(;;) { boost::shared_ptr<CListener> pListener1(new CListener); boost::shared_ptr<CListener> pListener2(new CListener); //    (  ) g_Lock.Lock(); g_Dispatcher.Subscribe(pListener1); g_Dispatcher.Subscribe(pListener2); g_Lock.Unlock(); Sleep(0); g_Lock.Lock(); g_Dispatcher.Unsubscribe(pListener1->GetSubscriberId()); g_Dispatcher.Unsubscribe(pListener2->GetSubscriberId()); g_Lock.Unlock(); } return 0; }

बहु-थ्रेडेड वातावरण के लिए अनुकूलित कार्यान्वयन

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

सब्सक्राइबर्स की लिस्ट को कॉपी करके फंक्शन में ट्रांसफर कर सकते हैं Subscribe / Unsubscribe यह लॉक-फ्री एल्गोरिदम की तकनीक के समान होगा।

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

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

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

 namespace Observer { ////////////////////////// // Subscriber ////////////////////////// typedef unsigned __int64 SubscriberId; class CSubscriber { public: virtual ~CSubscriber(){} virtual void MessageHandler(void* pContext) = 0; virtual void UnsubscribeHandler() = 0; SubscriberId GetSubscriberId() {return (SubscriberId)this;} }; typedef boost::shared_ptr<CSubscriber> CSubscriberPtr; ////////////////////////////////////////////////////////////////////// // Dispatcher /////////////////////////////////// class CDispatcher { private: class CSubscriberItem { public: CSubscriberItem(CSubscriberPtr pSubscriber) :m_pSubscriber(pSubscriber) { } ~CSubscriberItem() { m_pSubscriber->UnsubscribeHandler(); }; CSubscriberPtr Subscriber()const {return m_pSubscriber;} private: CSubscriberPtr m_pSubscriber; }; typedef boost::shared_ptr<CSubscriberItem> CSubscriberItemPtr; typedef std::vector<CSubscriberItemPtr> CSubscriberList; typedef boost::shared_ptr<CSubscriberList> CSubscriberListPtr; public: CDispatcher() { } private: CDispatcher(const CDispatcher&){} CDispatcher& operator=(const CDispatcher&){return *this;} public: SubscriberId Subscribe(CSubscriberPtr pNewSubscriber) { //Declaration of the next shared pointer before ScopeLocker //prevents release of subscribers from under lock CSubscriberListPtr pNewSubscriberList(new CSubscriberList()); //Enter to locked section CScopeLocker ScopeLocker(m_Lock); if(m_pSubscriberList) { //Copy existing subscribers pNewSubscriberList->assign(m_pSubscriberList->begin(), m_pSubscriberList->end()); } for(size_t i = 0; i < pNewSubscriberList->size(); ++i) { CSubscriberItemPtr pSubscriberItem = (*pNewSubscriberList)[i]; if(pSubscriberItem->Subscriber()->GetSubscriberId() == pNewSubscriber->GetSubscriberId()) { return 0; } } //Add new subscriber to new subscriber list pNewSubscriberList->push_back(CSubscriberItemPtr(new CSubscriberItem(pNewSubscriber))); //Exchange subscriber lists m_pSubscriberList = pNewSubscriberList; return pNewSubscriber->GetSubscriberId(); } bool Unsubscribe(SubscriberId id) { //Declaration of the next shared pointers before ScopeLocker //prevents release of subscribers from under lock CSubscriberItemPtr pSubscriberItemToRelease; CSubscriberListPtr pNewSubscriberList; //Enter to locked section CScopeLocker ScopeLocker(m_Lock); if(!m_pSubscriberList) { //No subscribers return false; } pNewSubscriberList = CSubscriberListPtr(new CSubscriberList()); for(size_t i = 0; i < m_pSubscriberList->size(); ++i) { CSubscriberItemPtr pSubscriberItem = (*m_pSubscriberList)[i]; if(pSubscriberItem->Subscriber()->GetSubscriberId() == id) { pSubscriberItemToRelease = pSubscriberItem; } else { pNewSubscriberList->push_back(pSubscriberItem); } } //Exchange subscriber lists m_pSubscriberList = pNewSubscriberList; if(!pSubscriberItemToRelease.get()) { return false; } return true; } void SendMessage(void* pContext) { CSubscriberListPtr pSubscriberList; { CScopeLocker ScopeLocker(m_Lock); if(!m_pSubscriberList) { //No subscribers return; } //Get shared pointer to an existing list of subscribers pSubscriberList = m_pSubscriberList; } //pSubscriberList pointer to copy of subscribers' list for(size_t i = 0; i < pSubscriberList->size(); ++i) { (*pSubscriberList)[i]->Subscriber()->MessageHandler(pContext); } } private: CSubscriberListPtr m_pSubscriberList; CLock m_Lock; }; }; //namespace Observer

संदर्भ

लाइब्रेरी को बढ़ावा दें :: सिग्नल 2 लेख

स्मार्ट प्वाइंट्स जेफ अल्जीरिया

संसाधन प्राप्ति प्रारंभिक (RAII) विकिपीडिया है

इस लेख के पहले संस्करण पर टिप्पणियाँ यहाँ पाई जा सकती हैं।

C ++ (अभ्यास) में बहुपरत पर्यवेक्षक