C ++ 11 [भाग 1] में धाराएँ, ताले और सशर्त चर

इस लेख का पहला भाग C ++ 11 में थ्रेड्स और लॉक पर केंद्रित होगा, उनके सभी महिमा में सशर्त चर दूसरे भाग में विस्तार से चर्चा की जाएगी ...

धाराओं

C ++ 11 में, थ्रेड्स के साथ काम std::thread माध्यम से किया जाता है std::thread क्लास ( <thread> हेडर फ़ाइल से सुलभ), जो नियमित कार्यों, लैम्ब्डा और फंक्शनलर्स के साथ काम कर सकता है। इसके अलावा, यह आपको स्ट्रीम फ़ंक्शन के लिए किसी भी संख्या में मापदंडों को पारित करने की अनुमति देता है।

 #include <thread> void threadFunction() { // do smth } int main() { std::thread thr(threadFunction); thr.join(); return 0; } 

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

 void threadFunction(int i, double d, const std::string &s) { std::cout << i << ", " << d << ", " << s << std::endl; } int main() { std::thread thr(threadFunction, 1, 2.34, "example"); thr.join(); return 0; } 

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

 void threadFunction(int &a) { a++; } int main() { int a = 1; std::thread thr(threadFunction, std::ref(a)); thr.join(); std::cout << a << std::endl; return 0; } 

प्रोग्राम कंसोल को प्रिंट करता है 2. यदि आप std::ref उपयोग नहीं करते हैं, तो प्रोग्राम का परिणाम 1 होगा।

join विधि के अलावा, आपको एक और, समान विधि पर विचार करना चाहिए - detach ।
detach आपको किसी ऑब्जेक्ट को एक स्ट्रीम से अलग detach अनुमति देता है, दूसरे शब्दों में, इसे पृष्ठभूमि बनाएं। join धागे अब डिस्कनेक्ट किए गए थ्रेड्स पर लागू नहीं किए जा सकते हैं।

 int main() { std::thread thr(threadFunction); thr.detach(); return 0; } 

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

 try { std::thread thr1(threadFunction); std::thread thr2(threadFunction); thr1.join(); thr2.join(); } catch (const std::exception &ex) { std::cout << ex.what() << std::endl; } 

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

 std::mutex g_mutex; std::vector<std::exception_ptr> g_exceptions; void throw_function() { throw std::exception("something wrong happened"); } void threadFunction() { try { throw_function(); } catch (...) { std::lock_guard<std::mutex> lock(g_mutex); g_exceptions.push_back(std::current_exception()); } } int main() { g_exceptions.clear(); std::thread thr(threadFunction); thr.join(); for(auto &e: g_exceptions) { try { if(e != nullptr) std::rethrow_exception(e); } catch (const std::exception &e) { std::cout << e.what() << std::endl; } } return 0; } 

आगे बढ़ने से पहले, मैं <thread> std::this_thread <thread> द्वारा std::this_thread में प्रदान किए गए कुछ उपयोगी कार्यों को इंगित करना चाहता std::this_thread :

• get_id : वर्तमान थ्रेड की आईडी लौटाता है
• पैदावार : अन्य सूत्र को निष्पादित करने के लिए अनुसूचक को बताता है, सक्रिय प्रतीक्षा के साथ इस्तेमाल किया जा सकता है
• sleep_for : एक निर्धारित अवधि के लिए वर्तमान थ्रेड के निष्पादन को रोकता है
• sleep_until : वर्तमान थ्रेड के निष्पादन को तब तक के लिए ब्लॉक करता है जब तक कि निर्धारित समय तक पहुँच न जाए

अवरुद्ध

पिछले उदाहरण में, मुझे यह सुनिश्चित करने के लिए g_exceptions वेक्टर की पहुंच को सिंक्रनाइज़ करना था कि एक समय में केवल एक धागा एक नया तत्व सम्मिलित कर सके। इसके लिए, मैंने म्यूटेक्स का उपयोग किया और म्यूटेक्स पर ताला लगा दिया। Mutex सिंक्रनाइज़ेशन का मूल तत्व है और C ++ 11 में इसे <mutex> हेडर फ़ाइल में 4 रूपों में प्रस्तुत किया गया है:

• म्यूटेक्स : बुनियादी फ़ंक्शन लॉक () और अनलॉक () और गैर-लॉक करने योग्य try_lock () विधि प्रदान करता है
• recursive_mutex : "अपने आप में" दर्ज कर सकता है
• timed_mutex : एक नियमित म्यूटेक्स के विपरीत, इसके दो और तरीके हैं: try_lock_for () और try_lock_until ()
• recursive_timed_mutex : यह timed_mutex और recursive_mutex का संयोजन है

यहाँ std::mutex का उपयोग करने का एक उदाहरण है std::mutex , get_id() और sleep_for() पहले उल्लेख किया गया है:

 #include <iostream> #include <chrono> #include <thread> #include <mutex> std::mutex g_lock; void threadFunction() { g_lock.lock(); std::cout << "entered thread " << std::this_thread::get_id() << std::endl; std::this_thread::sleep_for(std::chrono::seconds(rand()%10)); std::cout << "leaving thread " << std::this_thread::get_id() << std::endl; g_lock.unlock(); } int main() { srand((unsigned int)time(0)); std::thread t1(threadFunction); std::thread t2(threadFunction); std::thread t3(threadFunction); t1.join(); t2.join(); t3.join(); return 0; } 

कार्यक्रम को कुछ इस तरह दिखाना चाहिए:

 entered thread 10144 leaving thread 10144 entered thread 4188 leaving thread 4188 entered thread 3424 leaving thread 3424 

सामान्य डेटा तक पहुंचने से पहले, म्यूटेक्स को lock विधि द्वारा लॉक किया जाना चाहिए, और सामान्य डेटा के साथ काम करने के बाद, इसे अनलॉक विधि द्वारा अनलॉक किया जाना चाहिए।

निम्न उदाहरण एक साधारण थ्रेड-सुरक्षित कंटेनर ( std::vector के आधार पर कार्यान्वित add() addrange() जिसमें कई तत्वों को जोड़ने के लिए एक तत्व और addrange() जोड़ने के लिए add() तरीके हैं।
नोट : और फिर भी यह कंटेनर कई कारणों से पूरी तरह से सुरक्षित नहीं है, जिसमें va_args का उपयोग शामिल है। इसके अलावा, dump() विधि कंटेनर से संबंधित नहीं होनी चाहिए, लेकिन एक स्टैंड-अलोन फ़ंक्शन होना चाहिए। इस उदाहरण का उद्देश्य म्यूटेक्स का उपयोग करने की बुनियादी अवधारणाओं को दिखाना है, और एक पूर्ण, त्रुटि रहित, थ्रेड-सुरक्षित कंटेनर नहीं बनाना है।

 template <typename T> class container { std::mutex _lock; std::vector<T> _elements; public: void add(T element) { _lock.lock(); _elements.push_back(element); _lock.unlock(); } void addrange(int num, ...) { va_list arguments; va_start(arguments, num); for (int i = 0; i < num; i++) { _lock.lock(); add(va_arg(arguments, T)); _lock.unlock(); } va_end(arguments); } void dump() { _lock.lock(); for(auto e: _elements) std::cout << e << std::endl; _lock.unlock(); } }; void threadFunction(container<int> &c) { c.addrange(3, rand(), rand(), rand()); } int main() { srand((unsigned int)time(0)); container<int> cntr; std::thread t1(threadFunction, std::ref(cntr)); std::thread t2(threadFunction, std::ref(cntr)); std::thread t3(threadFunction, std::ref(cntr)); t1.join(); t2.join(); t3.join(); cntr.dump(); return 0; } 

जब इस कार्यक्रम को निष्पादित किया जाता है, तो गतिरोध उत्पन्न होगा (गतिरोध, यानी एक अवरुद्ध धागा अभी भी इंतजार करेगा)। कारण यह है कि कंटेनर म्यूटेक्स को रिलीज़ होने से पहले कई बार प्राप्त करने की कोशिश करता है (कॉल unlock ), जो असंभव है। यहाँ std::recursive_mutex दृश्य में प्रवेश करता है, जो आपको कई बार एक ही म्यूटेक्स प्राप्त करने की अनुमति देता है। एक म्यूटेक्स प्राप्त करने की अधिकतम मात्रा को परिभाषित नहीं किया गया है, लेकिन अगर यह राशि तक पहुंच जाती है, तो lock अपवाद std :: system_error फेंक देगा । इसलिए, ऊपर दिए गए कोड में समस्या का समाधान ( addrange() के कार्यान्वयन को बदलने के अलावा addrange() ताकि lock और unlock बुलाया न जाए), mutex को std::recursive_mutex से बदलना है।

 template <typename T> class container { std::recursive_mutex _lock; // ... }; 

अब, कार्यक्रम का परिणाम इस प्रकार होगा:

 6334 18467 41 6334 18467 41 6334 18467 41 

आपने शायद देखा कि जब आप threadFunction() , तो समान संख्याएं उत्पन्न होती हैं। इसका कारण यह है कि फ़ंक्शन void srand (unsigned int seed); केवल मुख्य धागे के लिए seed इनिशियलाइज़ करता है। अन्य थ्रेड्स में, छद्म यादृच्छिक संख्या जनरेटर को आरंभीकृत नहीं किया जाता है और हर बार समान संख्याएं प्राप्त की जाती हैं।
स्पष्ट लॉकिंग और अनलॉकिंग से त्रुटियां हो सकती हैं, उदाहरण के लिए, यदि आप थ्रेड को अनलॉक करना भूल जाते हैं या इसके विपरीत, ताले का एक गलत क्रम है - यह सब गतिरोध का कारण होगा। Std इस समस्या को हल करने के लिए कई कक्षाएं और फ़ंक्शन प्रदान करता है।
रैपर कक्षाएं आपको आरएआई शैली में एक म्यूटेक्स को स्वचालित लॉकिंग और एकल ब्लॉक के भीतर अनलॉक करने के साथ लगातार उपयोग करने की अनुमति देती हैं। ये वर्ग हैं:

• लॉक_गार्ड : जब कोई ऑब्जेक्ट बनाया जाता है, तो वह म्यूटेक्स ( lock() को कॉल करके lock() प्राप्त करने की कोशिश करता है, और जब ऑब्जेक्ट नष्ट हो जाता है, तो यह स्वचालित रूप से म्यूटेक्स ( unlock() कॉल करके) जारी करता है।
• अद्वितीय_लॉक : लॉक_गार्ड के विपरीत, यह आस्थगित लॉकिंग, अस्थायी लॉकिंग, पुनरावर्ती लॉकिंग और सशर्त चर के उपयोग का भी समर्थन करता है

इसे ध्यान में रखते हुए, हम निम्नानुसार कंटेनर वर्ग को फिर से लिख सकते हैं:

 template <typename T> class container { std::recursive_mutex _lock; std::vector<T> _elements; public: void add(T element) { std::lock_guard<std::recursive_mutex> locker(_lock); _elements.push_back(element); } void addrange(int num, ...) { va_list arguments; va_start(arguments, num); for (int i = 0; i < num; i++) { std::lock_guard<std::recursive_mutex> locker(_lock); add(va_arg(arguments, T)); } va_end(arguments); } void dump() { std::lock_guard<std::recursive_mutex> locker(_lock); for(auto e: _elements) std::cout << e << std::endl; } }; 

यह तर्क दिया जा सकता है कि dump() विधि स्थिर होनी चाहिए, क्योंकि यह कंटेनर की स्थिति को नहीं बदलता है। इसे इस तरह बनाने की कोशिश करें और एक संकलन त्रुटि प्राप्त करें:

 'std::lock_guard<_Mutex>::lock_guard(_Mutex &)' : cannot convert parameter 1 from 'const std::recursive_mutex' to 'std::recursive_mutex &' 

म्यूटेक्स (कार्यान्वयन के रूप की परवाह किए बिना) प्राप्त किया जाना चाहिए और जारी किया जाना चाहिए, और यह गैर-स्थिर तरीकों lock() और unlock() । इस प्रकार, lock_guard तर्क स्थिर नहीं हो सकता है। इस समस्या का समाधान म्यूटेक्स को mutable बनाना है, फिर कॉन्स्टेबल को नजरअंदाज कर दिया जाएगा और यह आपको निरंतर कार्यों से राज्य को बदलने की अनुमति देगा।

 template <typename T> class container { mutable std::recursive_mutex _lock; std::vector<T> _elements; public: void dump() const { std::lock_guard<std::recursive_mutex> locker(_lock); for(auto e: _elements) std::cout << e << std::endl; } }; 

आवरण वर्गों के निर्माता एक पैरामीटर ले सकते हैं जो लॉकिंग नीति को परिभाषित करता है:

• defer_lock type defer_lock_t : म्यूटेक्स प्राप्त न करें
• try_to_lock type try_to_lock_t : लॉक किए बिना म्यूटेक्स प्राप्त करने का प्रयास करें
• adopt_lock type को adopt_lock_t : यह माना जाता है कि कॉलिंग थ्रेड में पहले से ही एक म्यूटेक्स है

उन्हें निम्नानुसार घोषित किया जाता है:

 struct defer_lock_t { }; struct try_to_lock_t { }; struct adopt_lock_t { }; constexpr std::defer_lock_t defer_lock = std::defer_lock_t(); constexpr std::try_to_lock_t try_to_lock = std::try_to_lock_t(); constexpr std::adopt_lock_t adopt_lock = std::adopt_lock_t(); 

म्यूटेक्स के लिए "रैपर" के अलावा, std एक या एक से अधिक म्यूटेक्स को लॉक करने के लिए कई तरीके भी प्रदान करता है:

• लॉक : डेडलॉक परिहार एल्गोरिथ्म ( lock() का उपयोग करके lock() , try_lock() और unlock() का उपयोग करके म्यूटेक्स को लॉक करता है
• try_lock : म्यूटेक्स को उस क्रम में ब्लॉक करने का प्रयास करता है जिसमें वे निर्दिष्ट किए गए थे

यहां गतिरोध का एक विशिष्ट उदाहरण है: हमारे पास तत्वों के साथ एक कंटेनर है और एक exchange() फ़ंक्शन है जो विभिन्न कंटेनरों के दो तत्वों को स्वैप करता है। थ्रेड सुरक्षा के लिए, फ़ंक्शन इन कंटेनरों तक पहुंच को सिंक्रनाइज़ करता है, प्रत्येक कंटेनर से जुड़ा म्यूटेक्स प्राप्त करता है।

 template <typename T> class container { public: std::mutex _lock; std::set<T> _elements; void add(T element) { _elements.insert(element); } void remove(T element) { _elements.erase(element); } }; void exchange(container<int> &c1, container<int> &c2, int value) { c1._lock.lock(); std::this_thread::sleep_for(std::chrono::seconds(1)); //  deadlock c2._lock.lock(); c1.remove(value); c2.add(value); c1._lock.unlock(); c2._lock.unlock(); } 

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

 int main() { srand((unsigned int)time(NULL)); container<int> cntr1; cntr1.add(1); cntr1.add(2); cntr1.add(3); container<int> cntr2; cntr2.add(4); cntr2.add(5); cntr2.add(6); std::thread t1(exchange, std::ref(cntr1), std::ref(cntr2), 3); std::thread t2(exchange, std::ref(cntr2), std::ref(cntr1), 6); t1.join(); t2.join(); return 0; } 

इस समस्या को हल करने के लिए, आप std::lock उपयोग कर सकते हैं, जो सुरक्षित (गतिरोध के संदर्भ में) तरीके से लॉकिंग की गारंटी देता है:

 void exchange(container<int> &c1, container<int> &c2, int value) { std::lock(c1._lock, c2._lock); c1.remove(value); c2.add(value); c1._lock.unlock(); c2._lock.unlock(); } 

जारी : सशर्त चर