C++ में मल्टीथ्रेडिंग एक ऐसी सुविधा है जो किसी को एक साथ कई कार्य करने की अनुमति देती है। थ्रेड निष्पादित होने वाली किसी विशेष प्रक्रिया की कार्यशील इकाई है। मल्टीथ्रेडिंग करने के लिए कई थ्रेड एक ही समय में एक-दूसरे से स्वतंत्र रूप से निष्पादित होते हैं।
C++ में मल्टीथ्रेडिंग कैसे कार्यान्वित करें
एक मल्टीथ्रेड प्रोग्राम में दो या दो से अधिक भाग होते हैं जो एक साथ चलने की प्रवृत्ति रखते हैं, प्रत्येक भाग को थ्रेड के रूप में जाना जाता है और निष्पादन के लिए एक अलग पथ होता है। मल्टीथ्रेडिंग करने के लिए कई थ्रेड एक ही समय में एक-दूसरे से स्वतंत्र रूप से निष्पादित होते हैं।
C++ में मल्टीथ्रेडिंग के लिए पूर्व आवश्यकताएँ
विंडोज़ पर, थ्रेड से संबंधित कार्य C++ 11 और उन्नत संस्करणों में किए जा सकते हैं। Dev-C++ कंपाइलर का उपयोग करते समय, डिफ़ॉल्ट रूप से यह C++ 3 संस्करण पर होता है, इसलिए इसे मैन्युअल रूप से C++ 11 संस्करण में बदलने की आवश्यकता होती है। भाषा मानक सेटिंग्स को बदलकर GNU C++11 वातावरण का चयन किया जा सकता है।
Dev-C++ कंपाइलर खोलें और टास्कबार में 'टूल्स' पर जाएं। 'कंपाइलर विकल्प' चुनें और फिर 'सेटिंग्स' चुनें, 'कोड जेनरेशन' ब्लॉक पर क्लिक करें, कमांड की एक सूची दिखाई देगी। 'भाषा मानक(-std)' से GNU C++11 चुनें और फिर OK पर क्लिक करें। अब यह कंपाइलर थ्रेड ऑपरेशंस को सपोर्ट करने के लिए पूरी तरह तैयार है।
GitHub से लाइब्रेरी डाउनलोड करें और उन्हें Cpp कंपाइलर के lib फ़ोल्डर में रखें। प्रोग्राम में इन लाइब्रेरीज़ को #include 'mingw.thread.h' और
std::थ्रेड thread_object ( प्रतिदेय ) ;
std::thread C++11 में #include 'mingw.thread.h' हेडर फ़ाइल द्वारा समर्थित है। यह एक थ्रेड क्लास है और एकल थ्रेड का प्रतिनिधित्व करता है। std::thread का उपयोग करके एक नया थ्रेड बनाया जाता है और इसमें एक कॉल करने योग्य पास किया जाता है। कॉल करने योग्य एक निष्पादन योग्य कोड है, जो थ्रेड चलने पर निष्पादित होता है। कॉल करने योग्य नीचे दिए गए तीन प्रकारों में से कोई भी हो सकता है:
जब कोई ऑब्जेक्ट बनाया जाता है, तो यह एक नया थ्रेड लॉन्च करता है, जो कॉल करने योग्य कोड को निष्पादित करता है।
फ़ंक्शन ऑब्जेक्ट का उपयोग करके थ्रेड का लॉन्च
थ्रेड लॉन्च करने के लिए एक फ़ंक्शन ऑब्जेक्ट को कॉल करने योग्य के रूप में उपयोग किया जा सकता है, ओवरलोड ऑपरेटर () इसे कॉल करने योग्य बनाता है:
क्लास फ़ंक्शन_ऑब्जेक्ट_क्लास {शून्य ऑपरेटर ( ) ( पैरामीटर )
{
कथन;
}
}
std::थ्रेड thread_object ( function_object_class ( ) , पैरामीटर )
ओवरलोड फ़ंक्शन कंस्ट्रक्टर को पहले ऑब्जेक्ट के रूप में और स्टेटमेंट्स को दूसरे ऑब्जेक्ट के रूप में प्रदान किया जाता है।
फ़ंक्शन पॉइंटर का उपयोग करके थ्रेड का लॉन्च
एक फ़ंक्शन पॉइंटर को परिभाषित किया जाता है, और फिर इसे थ्रेड लॉन्च करने के लिए कॉल करने योग्य के रूप में उपयोग किया जाता है:
शून्य फ़ंक्शन_कॉल ( परम ){
कथन;
}
std::थ्रेड thread_obj ( फ़ंक्शन_कॉल, पैरामीटर ) ;
पारित किये जाने वाले तर्क फ़ंक्शन के नाम के बाद लिखे जाते हैं।
लैम्ब्डा एक्सप्रेशन का उपयोग करके थ्रेड का लॉन्च
थ्रेड ऑब्जेक्ट को कॉल करने योग्य के रूप में लैम्ब्डा का उपयोग करके लॉन्च किया जा सकता है।
// लैम्ब्डा अभिव्यक्ति को परिभाषित करेंऑटो एफ = [ ] ( पैरामीटर )
{
कथन;
} ;
std::थ्रेड thread_object ( एफ, पैराम्स ) ;
लैम्ब्डा एक्सप्रेशन को परिभाषित किया गया है, और थ्रेड लॉन्च करने के लिए इसमें पैरामीटर्स को कॉल किया जाता है।
कुछ मामलों में, अगले कमांड को निष्पादित करने से पहले थ्रेड को रोकना पड़ता है। std::thread::join () फ़ंक्शन का उपयोग थ्रेड समाप्त होने की प्रतीक्षा करने के लिए किया जाता है। उदाहरण के लिए, यदि हम थ्रेड को जीयूआई का कार्य सौंपते हैं, तो हमें पहले जीयूआई को ठीक से लोड करने के लिए इसके खत्म होने के समय की प्रतीक्षा करनी होगी और फिर अगले कमांड का निष्पादन होगा।
मुख्य प्रवेश बिंदु ( ){
std::थ्रेड t1 ( प्रतिदेय ) ;
t1.जुड़ें ( ) ;
कथन;
}
उदाहरण
यह एक प्रोग्राम है जिसे तीनों कॉलेबल का उपयोग करके मल्टीथ्रेडिंग करने के लिए निष्पादित किया जाता है। तीन अलग-अलग कॉल करने योग्य एक-दूसरे से बाधित हुए बिना अपने संबंधित आदेशों को एक साथ तीन बार निष्पादित करते हैं:
#शामिल करें#<थ्रेड>शामिल करें
नेमस्पेस एसटीडी का उपयोग करना;
शून्य फू ( int Z )
{
के लिए ( पूर्णांक मैं = 0 ; मैं < जेड; मैं++ ) {
अदालत << 'फ़ंक्शन का उपयोग कर थ्रेड'
'सूचक कॉल करने योग्य के रूप में \एन ' ;
}
}
क्लास थ्रेड_ओबीजे {
जनता:
शून्य ऑपरेटर ( ) ( इंट एक्स )
{
के लिए ( पूर्णांक मैं = 0 ; मैं < एक्स; मैं++ )
अदालत << 'फ़ंक्शन का उपयोग कर थ्रेड'
'ऑब्जेक्ट को कॉल करने योग्य के रूप में \एन ' ;
}
} ;
// मुख्य कोड
मुख्य प्रवेश बिंदु ( )
{
अदालत << 'थ्रेड्स 1 और 2 और 3'
'स्वतंत्र रूप से संचालन'
<< एंडल;
धागा th1 ( फू, 3 ) ;
धागा th2 ( thread_obj ( ) , 3 ) ;
ऑटो एफ = [ ] ( इंट एक्स ) {
के लिए ( पूर्णांक मैं = 0 ; मैं < एक्स; मैं++ )
अदालत << 'लैम्ब्डा का उपयोग कर धागा'
'अभिव्यक्ति कॉल करने योग्य के रूप में \एन ' ;
} ;
धागा th3 ( एफ, 3 ) ;
th1.जुड़ें ( ) ;
th2.जुड़ें ( ) ;
th3.जुड़ें ( ) ;
वापस करना 0 ;
}
इस प्रोग्राम में फ़ंक्शन पॉइंटर, फ़ंक्शन ऑब्जेक्ट और लैम्ब्डा एक्सप्रेशन सहित तीन कॉलेबल का उपयोग तीन थ्रेड्स को एक साथ लॉन्च करने के लिए किया जाता है। थ्रेड 1, 2, और 3 एक-दूसरे से बाधित हुए बिना, एक-दूसरे से स्वतंत्र होकर, अपने मानों को समवर्ती रूप से प्रिंट करते हैं। वे अपने मूल्यों को तीन बार मुद्रित करते हैं। थ्रेड समाप्त होने की प्रतीक्षा करने के लिए जॉइन() फ़ंक्शन का उपयोग किया जाता है।
तीनों थ्रेड के आउटपुट स्वतंत्र रूप से दिखाए जाते हैं और तीन बार दोहराए जाते हैं। प्रत्येक धागा दूसरे के पहले ख़त्म होने का इंतज़ार करता है।
निष्कर्ष
C++ में मल्टीथ्रेडिंग एक ऐसी सुविधा है जो किसी को एक साथ कई कार्य करने की अनुमति देती है। मल्टीथ्रेड प्रोग्राम में दो या दो से अधिक अनुभाग होते हैं जो एक साथ चल सकते हैं, प्रत्येक भाग को थ्रेड के रूप में जाना जाता है और निष्पादन के लिए एक अलग पथ होता है। थ्रेड्स, फ़ंक्शन पॉइंटर्स, फ़ंक्शन ऑब्जेक्ट्स और लैम्ब्डा एक्सप्रेशन लॉन्च करने के लिए तीन कॉल करने योग्य हैं। ये मल्टीथ्रेडिंग को सक्षम करते हैं।