Std :: thread का उपयोग करके अपने पैर को शूट करने का दूसरा तरीका

C ++ 11 मानक ने मानक थ्रेड सपोर्ट मैकेनिज्म को भाषा में पेश किया (उन्हें अक्सर स्ट्रीम कहा जाता है, लेकिन यह शब्द धाराओं के साथ भ्रम पैदा करता है, इसलिए मैं मूल अंग्रेजी शब्द का उपयोग रूसी प्रतिलेखन में करूंगा)। हालाँकि, C ++ में किसी भी तंत्र की तरह, यह आपके पैर को शूट करने के लिए कई तरह के ट्रिक्स, सूक्ष्मताएं और पूरी तरह से नए तरीके अपनाता है। हाल ही में, इस तरह के 20 तरीकों के बारे में एक लेख का अनुवाद हैबे पर दिखाई दिया, लेकिन यह सूची संपूर्ण नहीं है। मैं एक और ऐसी विधि के बारे में बात करना चाहता हूं जो std::thread को शुरू करने से संबंधित है std::thread निर्माण में std::thread उदाहरण।

यहाँ std::thread का उपयोग करने का एक सरल उदाहरण दिया गया है:

 class Usage { public: Usage() : th_([this](){ run(); }) {} void run() { // Run in thread } private: std::thread th_; }; 

इस सरलतम उदाहरण में, कोड सही दिखता है, लेकिन एक जिज्ञासु BUT है: कंस्ट्रक्टर std::thread को कॉल करने के समय std::thread उपयोग वर्ग का उदाहरण अभी तक पूरी तरह से निर्मित नहीं हुआ है। इस प्रकार, Usage::run() को एक उदाहरण के लिए कहा जा सकता है, जिनमें से कुछ फ़ील्ड ( std::thread फ़ील्ड के बाद घोषित) को अभी तक आरंभीकृत नहीं किया गया है, जो बदले में, यूबी को जन्म दे सकता है। यह एक छोटे से उदाहरण में स्पष्ट हो सकता है जहां वर्ग कोड स्क्रीन पर फिट बैठता है, लेकिन वास्तविक परियोजनाओं में यह जाल एक शाखा विरासत संरचना के पीछे छिपा हो सकता है। आइए प्रदर्शन को थोड़ा जटिल करें:

 class Usage { public: Usage() : th_([this](){ run(); }) {} virtual ~Usage() noexcept {} virtual void run() {} private: std::thread th_; }; class BadUsage : public Usage { public: BadUsage() : ptr_(new char[100]) {} ~BadUsage() { delete[] ptr_; } void run() { std::memcpy(ptr_, "Hello"); } private: char* ptr_; }; 

पहली नज़र में, कोड भी काफी सामान्य लग रहा है, इसके अलावा, यह लगभग हमेशा अपेक्षा के अनुरूप काम करेगा ... जब तक कि तारों को जोड़ न दें ताकि BadUsage::run() ptr_ आरंभीकृत करने से पहले कहा ptr_ । इसे प्रदर्शित करने के लिए, आरंभीकरण से पहले एक छोटी सी देरी जोड़ें:

 class BadUsage : public Usage { public: BadUsage() : ptr_((std::this_thread::sleep_for(std::chrono::milliseconds(1)), new char[100])) {} ~BadUsage() { delete[] ptr_; } void run() { std::memcpy(ptr_, "Hello", 6); } private: char* ptr_; }; 

इस स्थिति में, BadUsage::run() परिणामस्वरूप सेगमेंटेशन दोष होता है , और BadUsage::run() गई मेमोरी तक पहुँचने के बारे में शिकायत करता है।

ऐसी स्थितियों से बचने के लिए, कई समाधान हैं। सबसे आसान विकल्प दो चरण के आरंभीकरण का उपयोग करना है:

 class TwoPhaseUsage { public: TwoPhaseUsage() = default; ~TwoPhaseUsage() noexcept {} void start() { th_.reset(new std::thread([this](){ run(); })); } virtual void run() {} void join() { if (th_ && th_->joinable()) { th_->join(); } } private: std::unique_ptr<std::thread> th_; }; class GoodUsage : public TwoPhaseUsage { public: GoodUsage() : ptr_((std::this_thread::sleep_for(std::chrono::milliseconds(1)), new char[100])) {} ~GoodUsage() noexcept { delete[] ptr_; } void run() { std::memcpy(ptr_, "Hello", sizeof("Hello")); } private: char* ptr_; }; // ... GoodUsage gu; gu.start(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); gu.join(); // ...