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

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

सशर्त चर

पहले वर्णित सिंक्रनाइज़ेशन विधियों के अलावा, C ++ 11 सशर्त चर के लिए समर्थन प्रदान करता है जो एक या एक से अधिक थ्रेड्स को अवरुद्ध करने की अनुमति देता है जब तक कि किसी अन्य थ्रेड से कोई सूचना प्राप्त नहीं होती है या एक पौराणिक स्परूप ("गलत / यादृच्छिक वेकअप") होता है।
<condition_variable> शीर्ष लेख में सशर्त चर के दो कार्यान्वयन उपलब्ध हैं:

• condition_variable : std::unique_lock निष्पादित करने से पहले प्रतीक्षा करने के लिए किसी भी थ्रेड की आवश्यकता होती है std::unique_lock
• condition_variable_any : एक अधिक सामान्य कार्यान्वयन जो किसी भी प्रकार के साथ काम करता है जिसे अवरुद्ध किया जा सकता है। यह कार्यान्वयन उपयोग करने के लिए अधिक महंगा (संसाधनों और प्रदर्शन के संदर्भ में) हो सकता है, इसलिए इसका उपयोग केवल तभी किया जाना चाहिए जब आपको उन अतिरिक्त सुविधाओं की आवश्यकता हो जो इसे प्रदान करती हैं

मैं वर्णन करूंगा कि सशर्त चर कैसे काम करते हैं:

• किसी शर्त के सही होने के लिए कम से कम एक धागा होने की प्रतीक्षा करनी चाहिए। वेटिंग थ्रेड को पहले unique_lock अमल करना चाहिए। इस लॉक को wait() विधि से पारित किया जाता है, जो म्यूटेक्स को मुक्त करता है और स्ट्रीम को तब तक रोकता है जब तक कि स्थिति चर से एक संकेत प्राप्त नहीं हो जाता है। जब ऐसा होता है, तो थ्रेड उठता है और lock फिर से निष्पादित होता है।
• कम से कम एक थ्रेड सिगनल होना चाहिए कि स्थिति सच हो गई है। अधिसूचित_ओन () का उपयोग करके एक संकेत भेजा जा सकता है, और प्रतीक्षा थ्रेड्स में से एक (किसी भी) को अनलॉक किया जाएगा, या सूचना_ल () , जो सभी प्रतीक्षा थ्रेड्स को अनलॉक करेगा।
• मल्टीप्रोसेसर सिस्टम में अनुमानित स्थिति पैदा करने वाली जागृत स्थिति बनाने में कुछ कठिनाइयों के कारण, अजीब वेकअप हो सकते हैं। इसका मतलब है कि धागे को जागृत किया जा सकता है, भले ही किसी ने सशर्त चर का संकेत न दिया हो। इसलिए, यह अभी भी जांचना आवश्यक है कि क्या प्रवाह के बाद जागृत स्थिति सही है या नहीं। क्योंकि झूठी जागृति कई बार हो सकती है, इस तरह के चेक को एक चक्र में आयोजित किया जाना चाहिए।

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

 #include <condition_variable> #include <iostream> #include <random> #include <thread> #include <mutex> #include <queue> std::mutex g_lockprint; std::mutex g_lockqueue; std::condition_variable g_queuecheck; std::queue<int> g_codes; bool g_done; bool g_notified; void workerFunc(int id, std::mt19937 &generator) { //   { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[worker " << id << "]\trunning..." << std::endl; } //   std::this_thread::sleep_for(std::chrono::seconds(1 + generator() % 5)); //   int errorcode = id*100+1; { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[worker " << id << "]\tan error occurred: " << errorcode << std::endl; } //    { std::unique_lock<std::mutex> locker(g_lockqueue); g_codes.push(errorcode); g_notified = true; g_queuecheck.notify_one(); } } void loggerFunc() { //   { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[logger]\trunning..." << std::endl; } //   ,      while(!g_done) { std::unique_lock<std::mutex> locker(g_lockqueue); while(!g_notified) //    g_queuecheck.wait(locker); //     ,   while(!g_codes.empty()) { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[logger]\tprocessing error: " << g_codes.front() << std::endl; g_codes.pop(); } g_notified = false; } } int main() { //   -  std::mt19937 generator((unsigned int)std::chrono::system_clock::now().time_since_epoch().count()); //   std::thread loggerThread(loggerFunc); //   std::vector<std::thread> threads; for(int i = 0; i < 5; ++i) threads.push_back(std::thread(workerFunc, i+1, std::ref(generator))); for(auto &t: threads) t.join(); //        g_done = true; loggerthread.join(); return 0; } 

इस कोड का निष्पादन लगभग निम्नलिखित परिणाम देगा (परिणाम हर बार अलग होगा, क्योंकि कार्यकर्ता सूत्र काम करते हैं (या बल्कि सोते समय) यादृच्छिक समय अंतराल):

 [logger] running... [worker 1] running... [worker 2] running... [worker 3] running... [worker 4] running... [worker 5] running... [worker 1] an error occurred: 101 [worker 2] an error occurred: 201 [logger] processing error: 101 [logger] processing error: 201 [worker 5] an error occurred: 501 [logger] processing error: 501 [worker 3] an error occurred: 301 [worker 4] an error occurred: 401 [logger] processing error: 301 [logger] processing error: 401 

ऊपर दी गई wait विधि में दो अधिभार हैं:

• एक जो केवल unique_lock का उपयोग करता है; वह (विधि) धागे को अवरुद्ध करता है और इसे इस स्थिति चर से संकेत की प्रतीक्षा कर रहे धागे की कतार में जोड़ता है; जब प्रवाह एक संकेत सशर्त चर से प्राप्त होता है या झूठे वेकअप के मामले में उठता है।
• unique_lock अलावा लूप में उपयोग किए गए विधेय को unique_lock स्वीकार करता है जब तक कि वह false ; इस अतिभार का उपयोग झूठी जागृति से बचने के लिए किया जा सकता है। सामान्य तौर पर, यह इस तरह एक लूप के बराबर होता है:
  

   while(!predicate()) wait(lock); 

इस प्रकार, दूसरे अधिभार का उपयोग करके, आप ऊपर के उदाहरण में बूलियन ध्वज g_notified का उपयोग करने से बच सकते हैं:

 void workerFunc(int id, std::mt19937 &generator) { //   { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[worker " << id << "]\trunning..." << std::endl; } //   std::this_thread::sleep_for(std::chrono::seconds(1 + generator() % 5)); //   int errorcode = id*100+1; { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[worker " << id << "]\tan error occurred: " << errorcode << std::endl; } //    { std::unique_lock<std::mutex> locker(g_lockqueue); g_codes.push(errorcode); g_queuecheck.notify_one(); } } void loggerFunc() { //   { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[logger]\trunning..." << std::endl; } //   ,      while(!g_done) { std::unique_lock<std::mutex> locker(g_lockqueue); g_queuecheck.wait(locker, [&](){return !g_codes.empty();}); //     ,   while(!g_codes.empty()) { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "[logger]\tprocessing error: " << g_codes.front() << std::endl; g_codes.pop(); } } } 

अतिभारित wait() विधि के अलावा, विधेय के लिए एक ही अधिभार के साथ दो और समान विधियां हैं:

• Wait_for : एक सशर्त चर सिग्नल प्राप्त होने तक थ्रेड को ब्लॉक करता है
• Wait_until : थ्रेड को ब्लॉक करता है जब तक एक सशर्त चर सिग्नल प्राप्त नहीं होता है या समय में एक निश्चित बिंदु तक पहुंच जाता है

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

Std भी Inform_all_at_thread_exit फ़ंक्शन प्रदान करता है, जो अन्य थ्रेड्स को सूचित करने के लिए एक तंत्र लागू करता है कि डेटा ने अपना काम पूरा कर लिया है, जिसमें सभी thread_local ऑब्जेक्ट्स का विनाश भी शामिल है। join अलावा किसी अन्य तंत्र द्वारा थ्रेड्स की प्रतीक्षा करने पर असामान्य व्यवहार हो thread_locals है जब thread_locals पहले ही उपयोग किए जा चुके हैं और उनके thread_locals को थ्रेड जागने के बाद या इसे पहले ही पूरा हो जाने के बाद बुलाया जा सकता है (देखें N3070 और N2880 । आमतौर पर, एक कॉल) यह कार्य थ्रेड के अस्तित्व में आने से ठीक पहले होना चाहिए। निम्नलिखित का एक उदाहरण है कि कैसे दो धागे को सिंक्रनाइज़ करने के लिए सशर्त चर के साथ notify_all_at_thread_exit का उपयोग किया जा सकता है:

 std::mutex g_lockprint; std::mutex g_lock; std::condition_variable g_signal; bool g_done; void workerFunc(std::mt19937 &generator) { { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "worker running..." << std::endl; } std::this_thread::sleep_for(std::chrono::seconds(1 + generator() % 5)); { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "worker finished..." << std::endl; } std::unique_lock<std::mutex> lock(g_lock); g_done = true; std::notify_all_at_thread_exit(g_signal, std::move(lock)); } int main() { std::mt19937 generator((unsigned int)std::chrono::system_clock::now().time_since_epoch().count()); std::cout << "main running..." << std::endl; std::thread worker(workerFunc, std::ref(generator)); worker.detach(); std::cout << "main crunching..." << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1 + generator() % 5)); { std::unique_lock<std::mutex> locker(g_lockprint); std::cout << "main waiting for worker..." << std::endl; } std::unique_lock<std::mutex> lock(g_lock); while(!g_done) //    g_signal.wait(lock); std::cout << "main finished..." << std::endl; return 0; } 

यदि कार्यकर्ता मुख्य सूत्र से पहले अपना काम पूरा कर लेता है, तो परिणाम इस प्रकार होगा:

 main running... worker running... main crunching... worker finished... main waiting for worker... main finished... 

यदि मुख्य धागा कार्यकर्ता थ्रेड से पहले अपना काम पूरा करता है, तो परिणाम इस प्रकार होगा:

 main running... worker running... main crunching... main waiting for worker... worker finished... main finished... 

निष्कर्ष में

C ++ 11 मानक C ++ डेवलपर्स को मानक, प्लेटफ़ॉर्म-स्वतंत्र तरीके से बहु-थ्रेडेड कोड लिखने की अनुमति देता है। यह लेख std से स्ट्रीम और सिंक्रोनाइज़ेशन तंत्र के माध्यम से केवल एक रन है। <thread> प्रतिनिधित्व करने वाला <thread> हेडर एक ही नाम (और कई अतिरिक्त फ़ंक्शन) के साथ एक वर्ग प्रदान करता है। <mutex> हेडर थ्रेड्स तक पहुंच को सिंक्रनाइज़ करने के लिए कई म्यूटेक्स और "रैपर" का कार्यान्वयन प्रदान करता है। <condition_variable> शीर्ष लेख सशर्त चर के दो कार्यान्वयन प्रदान करता है जो आपको एक या एक से अधिक थ्रेड्स ब्लॉक करने की अनुमति देते हैं, जब तक कि आप किसी अन्य धागे से या झूठी जागृति से पहले एक अधिसूचना प्राप्त न करें। मामले की अधिक विस्तृत जानकारी और समझ के लिए, निश्चित रूप से, अतिरिक्त साहित्य पढ़ने की सिफारिश की गई है :)