पुस्तक "सी ++। मल्टीथ्रेडेड प्रोग्रामिंग का अभ्यास "

हाय, हब्रोज़ितेली! C ++ भाषा का चयन तब किया जाता है जब आपको सही मायने में बिजली की तेजी से अनुप्रयोगों को बनाने की आवश्यकता होती है। और उच्च गुणवत्ता वाले प्रतिस्पर्धी प्रसंस्करण उन्हें और भी तेज कर देगा। C ++ 17 की नई विशेषताएं आपको ग्राफिक प्रोसेसिंग, मशीन लर्निंग, आदि की समस्याओं को आसानी से हल करने के लिए मल्टी-थ्रेडेड प्रोग्रामिंग की पूरी शक्ति का उपयोग करने की अनुमति देती हैं, एंथनी विलियम्स, जो प्रतिस्पर्धी प्रोसेसिंग में एक विशेषज्ञ हैं, उदाहरणों पर विचार करती हैं और व्यावहारिक कार्यों का वर्णन करती हैं, साथ ही सभी के लिए उपयोगी रहस्यों को भी साझा करती हैं। सबसे अनुभवी डेवलपर्स सहित।

पुस्तक में • C ++ 17 की विशेषताओं का पूरा अवलोकन। • लॉन्च और प्रवाह नियंत्रण। • प्रतिस्पर्धी संचालन का सिंक्रनाइज़ेशन। • प्रतिस्पर्धी कोड का विकास। • मल्टीथ्रेडेड अनुप्रयोगों को डीबग करना। पुस्तक C और C ++ का उपयोग करने वाले मध्य-स्तरीय डेवलपर्स के लिए उपयुक्त है। प्रतिस्पर्धी प्रोग्रामिंग अनुभव की आवश्यकता नहीं है।

प्रतिस्पर्धी कोड विकास

8.1। धागे के बीच काम को वितरित करने के तरीके

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

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

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

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

8.1.1। प्रसंस्करण से पहले थ्रेड्स के बीच डेटा का वितरण

समानांतर करने के लिए सबसे आसान सरल एल्गोरिदम हैं, जैसे कि std :: for_each, जो डेटा सेट के प्रत्येक तत्व पर संचालन करते हैं। इस एल्गोरिथ्म को समानांतर करने के लिए, आप प्रत्येक तत्व को प्रसंस्करण थ्रेड्स में से किसी एक को असाइन कर सकते हैं। भविष्य में, प्रदर्शन के मुद्दों पर विचार करते समय, यह स्पष्ट हो जाएगा कि इष्टतम प्रदर्शन प्राप्त करने के लिए सबसे अच्छा वितरण विकल्प डेटा संरचना की विशेषताओं पर निर्भर करता है।

डेटा वितरित करते समय, सबसे सरल मामला तब होता है जब पहले एन तत्वों को एक स्ट्रीम में सौंपा जाता है, अगले एन तत्वों को दूसरे को, और इसी तरह (छवि। 8.1), लेकिन अन्य योजनाओं का उपयोग किया जा सकता है। डेटा वितरण की विधि के बावजूद, प्रत्येक थ्रेड प्रक्रिया को सौंपे गए तत्वों को केवल अन्य थ्रेड्स के साथ इंटरैक्ट किए बिना संसाधित करता है।


संदेश पासिंग इंटरफ़ेस (MPI, www.mpi-forum.org ) या OpenMP (http://www.openmp.org/) में प्रोग्रामिंग से निपटने वाले सभी लोगों के लिए संरचना परिचित होनी चाहिए: कार्य समानांतर में किए जाने वाले कई कार्यों में विभाजित है, वर्कफ़्लो उन्हें एक-दूसरे से स्वतंत्र रूप से चलाते हैं, और परिणाम जानकारी के अंतिम चरण में एकत्र किए जाते हैं। इस दृष्टिकोण का उपयोग उदाहरण में धारा 2.4 से संचित फ़ंक्शन के साथ किया गया था: समानांतर कार्य और कमी चरण दोनों संचय हैं। एक सरल for_each एल्गोरिथ्म के लिए, अंतिम चरण गायब है, क्योंकि कम करने के लिए कुछ भी नहीं है।

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

इसकी सभी प्रभावशीलता के लिए, यह तकनीक बहुमुखी नहीं है। कभी-कभी डेटा को पहले से सटीक रूप से विभाजित नहीं किया जा सकता है, क्योंकि प्रत्येक भाग की संरचना केवल प्रसंस्करण के दौरान ज्ञात हो जाती है। विशेष रूप से, रिकर्सिव एल्गोरिदम जैसे क्विकसॉर्ट का उपयोग करते समय यह स्पष्ट है, इसलिए उन्हें एक अलग दृष्टिकोण की आवश्यकता होती है।

8.1.2। पुनरावर्ती डेटा वितरण

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

यह कार्यान्वयन पहले से ही अध्याय 4 में मिला था। बड़े और छोटे हिस्सों के लिए दो पुनरावर्ती कॉल करने के बजाय, हमने std :: async () फ़ंक्शन का उपयोग किया, जो प्रत्येक चरण में छोटे आधे के लिए अतुल्यकालिक कार्य चलाता है। Std :: async () के उपयोग के कारण, C ++ थ्रेड लाइब्रेरी को यह तय करना था कि नए थ्रेड में कार्य कब शुरू किया जाए, और जब - सिंक्रोनस मोड में।

एक महत्वपूर्ण परिस्थिति है: एक बड़े डेटा सेट को छांटते समय, प्रत्येक पुनरावृत्ति के लिए एक नया धागा शुरू करने से थ्रेड्स की संख्या में तेजी से वृद्धि होगी। प्रदर्शन के मुद्दों की जांच करते समय, यह दिखाया जाएगा कि बहुत से धागे आवेदन को धीमा कर सकते हैं। इसके अलावा, डेटा प्रवाह के एक बड़े सेट के साथ बस पर्याप्त नहीं हो सकता है। इस तरह के एक पुनरावर्ती मोड में पूरे कार्य को विभाजित करने का बहुत विचार बहुत सफल लगता है, आपको केवल थ्रेड्स की संख्या की सावधानीपूर्वक निगरानी करने की आवश्यकता है। साधारण मामलों में, std :: async () फ़ंक्शन इसे संभालता है, लेकिन अन्य विकल्प भी हैं।


उनमें से एक std :: थ्रेड :: hardware_concurrency () फ़ंक्शन का उपयोग थ्रेड्स की संख्या का चयन करने के लिए है, जैसा कि संचित 2.9 के समांतर संस्करण () फ़ंक्शन से किया गया था। फिर, प्रत्येक पुनरावर्ती कॉल के लिए एक नया धागा शुरू करने के बजाय, आप एक थ्रेड-सुरक्षित स्टैक पर सॉर्ट किए जाने के लिए टुकड़ा रख सकते हैं, उदाहरण के लिए, अध्याय 6 और 7 में चर्चा की गई है। यदि थ्रेड का कोई लेना देना नहीं है या उसने अपने टुकड़ों को संसाधित करना समाप्त कर दिया है या टुकड़े के छंटने का इंतजार कर रहा है, तो यह हो सकता है। स्टैक से एक टुकड़ा लें और इसे सॉर्ट करें।

8.1 को सूचीबद्ध करना इस तकनीक का एक सरल कार्यान्वयन दर्शाता है। अधिकांश अन्य उदाहरणों की तरह, यह केवल आशय को प्रदर्शित करता है, और व्यावहारिक उपयोग के लिए तैयार कोड नहीं है। यदि आप C ++ 17 कंपाइलर का उपयोग करते हैं और आपकी लाइब्रेरी इसका समर्थन करती है, तो आपको मानक लाइब्रेरी द्वारा दिए गए समानांतर एल्गोरिदम का उपयोग अध्याय 10 में दिए गए विवरणों के अनुसार करना चाहिए।

लिस्टिंग 8.1। एक समानांतर क्विकसॉर्ट एल्गोरिथ्म जो छँटाई की प्रतीक्षा में टुकड़ों के ढेर का उपयोग करता है





यहां, समांतर_क्विक_सॉर्ट (19) फ़ंक्शन सॉर्टर (1) वर्ग पर कार्यात्मक जिम्मेदारियों के थोक को रखता है, जो कि अनसुने टुकड़ों (2) और कई थ्रेड्स (3) के ढेर को समूहित करने का एक आसान तरीका प्रदान करता है। मुख्य कार्य do_sort घटक फ़ंक्शन (9) में किया जाता है, जो सामान्य डेटा विभाजन (10) द्वारा कब्जा कर लिया जाता है। इस बार, प्रत्येक टुकड़े के लिए एक नया धागा शुरू करने के बजाय, यह इस टुकड़े को स्टैक (11) पर धकेलता है और केवल एक नया प्रोसेसर शुरू करता है, अगर कोई मुफ्त प्रोसेसर संसाधन (12) है। चूंकि संदर्भ से कम मूल्यों वाले टुकड़े को किसी अन्य धारा द्वारा संसाधित किया जा सकता है, हमें इसकी तत्परता (13) की प्रतीक्षा करनी चाहिए। ताकि समय बर्बाद न हो (इस घटना में कि हमारे पास एक ही धागा है या अन्य सभी धागे पहले से ही कब्जे में हैं), इस प्रतीक्षा अवधि (14) के लिए स्टैक से टुकड़ों को संसाधित करने का प्रयास किया जाता है। Try_sort_chunk फ़ंक्शन स्टैक (7) से एक टुकड़ा प्राप्त करता है, इसे क्रमबद्ध करता है (8), और वादे के वादे में परिणाम बचाता है ताकि वे उस खंड को प्राप्त कर सकें जो इस टुकड़े को स्टैक (15) पर डालते हैं।

अब, केवल लॉन्च किए गए थ्रेड्स लूप में हैं और स्टैक (17) से टुकड़े को सॉर्ट करने की कोशिश करते हैं यदि एंड_ऑफ_डेटा (16) झंडा सेट नहीं है। चेक के बीच, वे अन्य थ्रेड्स के लिए कंप्यूटिंग संसाधन छोड़ देते हैं ताकि वे स्टैक पर अतिरिक्त काम को धक्का दे सकें। इन थ्रेड्स को क्रम में रखने के संदर्भ में कोड का काम आपके सॉर्टर (4) वर्ग के विध्वंसक पर निर्भर करता है। जब सभी डेटा को सॉर्ट किया जाता है, तो do_sort फ़ंक्शन नियंत्रण लौटा देगा (यहां तक ​​कि कार्यकर्ता थ्रेड्स की गतिविधि को बनाए रखते हुए), मुख्य थ्रेड समानांतर_क्विक_सॉर्ट (20) से वापस आ जाएगा और सॉर्टर ऑब्जेक्ट को नष्ट कर देगा। यह end_of_data ध्वज (5) को सेट करेगा और थ्रेड्स के समाप्त होने का इंतजार करेगा (6)। ध्वज की स्थापना से थ्रेड्स फ़ंक्शन (16) में लूप बंद हो जाएगा।

इस दृष्टिकोण के साथ, नए थ्रेड को लॉन्च करने वाले स्पॉन_टैस्क फ़ंक्शन में निहित असीमित संख्या में थ्रेड्स की समस्या गायब हो जाएगी और C ++ थ्रेड लाइब्रेरी पर निर्भरता, जो आपके लिए थ्रेड्स की संख्या का चयन करेगी, जैसा कि यह तब होता है जब std :: async (), गायब हो जाएगा। इसके बजाय, अक्सर कार्य स्विचन को रोकने के लिए, थ्रेड्स की संख्या std :: thread :: हार्डवेयर_concurrency () फ़ंक्शन द्वारा लौटाए गए मान से सीमित होती है। लेकिन एक और समस्या उत्पन्न होती है: इन धाराओं को प्रबंधित करना और उनके बीच डेटा का आदान-प्रदान करना कोड को बहुत जटिल करता है। इसके अलावा, इस तथ्य के बावजूद कि थ्रेड्स व्यक्तिगत डेटा तत्वों को संसाधित करते हैं, उनमें से सभी स्टैक तक पहुंचते हैं, इसके लिए नए टुकड़े जोड़ते हैं और प्रसंस्करण के लिए टुकड़े लेते हैं। इस तरह की गहन प्रतियोगिता प्रदर्शन को कम कर सकती है, भले ही लॉक-फ्री (इसलिए, गैर-अवरुद्ध) स्टैक का उपयोग किया जाता है, और इसके कारणों पर जल्द ही विचार किया जाएगा।

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

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

8.1.3। कार्य प्रकार द्वारा कार्य का वितरण

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

प्रतिस्पर्धा की मदद से कार्यों के पृथक्करण के परिणामस्वरूप श्रम का यह अजीब विभाजन उत्पन्न होता है: प्रत्येक थ्रेड में एक अलग कार्य होता है, जिसे यह अन्य प्रवाह के स्वतंत्र रूप से करता है। कभी-कभी अन्य थ्रेड्स स्ट्रीम को डेटा प्रदान कर सकते हैं या उन घटनाओं का उत्पादन कर सकते हैं जिन्हें इसका जवाब देना चाहिए, लेकिन सामान्य तौर पर, प्रत्येक स्ट्रीम एकल कार्य के उच्च-गुणवत्ता वाले प्रदर्शन पर ध्यान केंद्रित करती है। यह एक अच्छा बेसिक डिज़ाइन है, जहाँ हर एक चीज़ के लिए कोड का टुकड़ा जिम्मेदार होना चाहिए।

जिम्मेदारी साझा करने के लिए कार्य के प्रकार से कार्य का वितरण

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

यहाँ प्रवाह मंच पर आते हैं। यदि आप प्रत्येक कार्य को एक अलग थ्रेड में चलाते हैं, तो ऑपरेटिंग सिस्टम आपके बजाय यह कर सकता है। कार्य ए के लिए कोड में, आप राज्य को बनाए रखने और मुख्य लूप में लौटने के बारे में चिंता किए बिना कार्य पूरा करने पर ध्यान केंद्रित कर सकते हैं, या ऐसा होने से पहले कितना समय बीत जाएगा। यही है, ऑपरेटिंग सिस्टम स्वचालित रूप से स्थिति को बचाएगा और सही समय पर कार्य B या C पर स्विच करेगा, और यदि जिस सिस्टम पर प्रोग्राम चलाया जाएगा, उसमें कई कोर या प्रोसेसर हैं, यह एक साथ कार्यों ए और बी को निष्पादित करने के लिए संभव होगा, जो किस्ट्रोक्स या रसीदों के प्रसंस्करण के लिए कोड है। नेटवर्क पैकेट अब समयबद्ध तरीके से निष्पादित किए जा सकते हैं, और सभी को लाभ होगा: उपयोगकर्ता को एक पर्याप्त कार्यक्रम प्रतिक्रिया प्राप्त होगी, और आप, एक डेवलपर के रूप में, सरलीकृत कोड प्राप्त करेंगे, क्योंकि प्रत्येक स्ट्रीम को निर्देशित किया जा सकता है। नियंत्रण प्रवाह और उपयोगकर्ता बातचीत के साथ मिश्रण किए बिना, सीधे अपने कर्तव्यों से संबंधित संचालन करने के लिए।

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

कई थ्रेड्स के बीच जिम्मेदारी साझा करने में दो गंभीर खतरे हैं। सबसे पहले, यह पता चल सकता है कि अनुचित जिम्मेदारियां वितरित की जाती हैं। इसका एक संकेत धाराओं द्वारा साझा किया गया बहुत अधिक डेटा या तथ्य यह है कि विभिन्न धाराओं को एक दूसरे के लिए इंतजार करना पड़ता है। . . , , , , . , , — , , .

. , , .

, . : , , .

— . , , . , , , .

, 8.1.1, , . , .

, : , . , 20 , 3 . , . , , , , 12 , 24 — . . 20 . . . , , , , 12 . , 12 , . , : , , , , , . 3 12 .

, 9 , . . , , . 25 , — . , , : , 100 , , 1 , 100 , 1 100 . , , . , , , .

, , , , .

8.2. ,

, , . , , . , 16 , .

, — , , ( ), . , : ?

8.2.1. ?

( ) , . , , , . , . , . , , ( ) . , , , .

16- 16 : 16 . , 16 . , , ( ). , 16 , , , 1. (oversubscription).

, , C++11 (Standard Thread Library) std::thread::hardware_concurrency(). .

std::thread::hardware_concurrency() : - , , . , , std::thread::hardware_concurrency(), . std::async() , . .

, , , . — , , . , , , , C++. , std::async(), , , . , . , , std::thread::hardware_concurrency(), . , , , .

, . , , , , .

, — .

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

25% — C++

पुस्तक के पेपर संस्करण के भुगतान पर, एक इलेक्ट्रॉनिक पुस्तक ई-मेल द्वारा भेजी जाती है।