मेन्यू

उदाहरणों के साथ C ++ में गुणा करना

multithreading c with examples

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

C ++ में मल्टीथ्रेडिंग करने के लिए एक संक्षिप्त परिचय।

इस ट्यूटोरियल में, हमें C ++ में मल्टीथ्रेडिंग का अवलोकन मिलेगा।

तो एक धागा क्या है? एक धागा एक विशेष प्रक्रिया की एक कार्य इकाई है। मल्टी-प्रोग्रामिंग ऑपरेटिंग सिस्टम में, विभिन्न प्रक्रियाएं एक साथ निष्पादित होती हैं।

इसी तरह, हम एक ही प्रक्रिया के उदाहरणों को एक साथ निष्पादित करना चाह सकते हैं। प्रत्येक प्रक्रिया उदाहरण, इस मामले में, थ्रेड नामक एक निष्पादन इकाई को सौंपा गया है। एक मल्टीथ्रेडिंग सिस्टम में, कई थ्रेड्स एक साथ एक दूसरे से स्वतंत्र निष्पादित होते हैं।

=> यहाँ सी ++ शुरुआती गाइड पर एक नज़र डालें।

मुख्य c ++ के लिए अपरिभाषित संदर्भ

C ++ में बहुउद्देशीय

C ++ 11 से पहले, हमारे पास POSIX थ्रेड समर्थन था। लेकिन इस फीचर में गंभीर पोर्टेबिलिटी की समस्या थी क्योंकि यह केवल लिनक्स या यूनिक्स ऑपरेटिंग सिस्टम पर काम करता था। इस प्रकार C ++ 11 के बाद से, हमारे पास एक एकल वर्ग है एसटीडी :: धागा जो धागे के लिए सभी कार्यक्षमता को परिभाषित करता है। हेडर फ़ाइल में कक्षाएं और फ़ंक्शन परिभाषित किए गए हैं।

आप क्या सीखेंगे:

का कार्य करना

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

एक बार जब std :: थ्रेड ऑब्जेक्ट बनाया जाता है, तो एक नया थ्रेड लॉन्च किया जाता है और कॉल करने योग्य कोड प्रदान किया जाता है।

आइए देखें कि हम थ्रेड ऑब्जेक्ट को प्रदान किए जाने वाले कॉल करने योग्य को कैसे परिभाषित कर सकते हैं।

एक कॉल करने योग्य को तीन तरीकों से परिभाषित किया जा सकता है।

# 1) फ़ंक्शन ऑब्जेक्ट का उपयोग करना

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

oracle pl sql उन्नत साक्षात्कार प्रश्न
/ / Define the class for function object class functioObject_class { // Overload () operator void operator()(params) { // code to be executed } }; // Create thread object std::thread thread_object(functioObject_class (), params)

थ्रेड ऑब्जेक्ट को परिभाषित करने के तरीके पर ध्यान दें। थ्रेड ऑब्जेक्ट के निर्माता के लिए पहले पैरामीटर के रूप में, हम ओवरलोड फ़ंक्शन प्रदान करते हैं और फिर दूसरे तर्क के रूप में इसके तर्क (परम) निर्दिष्ट करते हैं।

# 2) समारोह सूचक का उपयोग करना

फ़ंक्शन पॉइंटर का उपयोग करके कॉल करने योग्य को निम्न तरीके से परिभाषित किया जा सकता है।

void funct_call(params) //code to be executed }

एक बार जब हम इस फ़ंक्शन को परिभाषित करते हैं, तो हम निम्न तरीके से, इस फ़ंक्शन के साथ एक कॉल ऑब्जेक्ट बना सकते हैं।

std::thread thread_obj(funct_call, params);

ध्यान दें कि फ़ंक्शन में दिए गए तर्क (परम), थ्रेड ऑब्जेक्ट में फ़ंक्शन नाम के बाद प्रदान किए जाते हैं।

# 3) एक लैम्ब्डा एक्सप्रेशन का उपयोग करना

हम एक लंबोदर अभिव्यक्ति के रूप में एक कॉल करने योग्य भी हो सकते हैं और इसे निष्पादन के लिए थ्रेड ऑब्जेक्ट को पास कर सकते हैं। उसी के लिए कोड स्निपेट नीचे दिखाया गया है।

// Define a lambda expression auto f = ()(params) { // code for execution }; std::thread thread_object(f, params);

उपरोक्त कोड में, हमने एक लैम्ब्डा एक्सप्रेशन f को परिभाषित किया है और हम इसे थ्रेड ऑब्जेक्ट कंस्ट्रक्टर के पास भेजते हैं, जिसके बाद पहला तर्क इसके पैरामीटर (परमेस) के बाद दूसरा तर्क के रूप में आता है।

std::thread join method

कुछ मामलों में, हम एक और कार्रवाई शुरू करने से पहले समाप्त करने के लिए वर्तमान में निष्पादित थ्रेड चाहते हैं।

एक क्लासिक उदाहरण है जब हम GUI एप्लिकेशन खोलते हैं। जिस क्षण हम एप्लिकेशन को खोलते हैं, GUI को लोड और इनिशियलाइज़ करने के लिए एक थ्रेड शुरू किया जाता है और हम कोई कार्रवाई तब तक नहीं कर सकते जब तक कि लोडिंग और इनिशियलाइज़ेशन सही ढंग से नहीं किया जाता है ताकि GUI ठीक से काम कर सके।

वर्ग std :: थ्रेड एक ज्वाइन () विधि प्रदान करता है जो यह सुनिश्चित करता है कि किसी भी अन्य क्रिया को करने से पहले वर्तमान थ्रेड (* द्वारा इंगित किया गया) पहले समाप्त हो जाए।

निम्नलिखित उदाहरण लें,

int main() { std::thread t1(callable_code); ….. t1.join(); ….. }

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

थ्रेड का उदाहरण

हम नीचे दिखाए गए कार्यक्रम में थ्रेड के निर्माण और निष्पादन के लिए एक पूर्ण कोडिंग उदाहरण प्रस्तुत करते हैं।

#include #include using namespace std; // function to be used in callable void func_dummy(int N) { for (int i = 0; i

आउटपुट:

सर्वश्रेष्ठ साइटों को ऑनलाइन देखने के लिए मोबाइल फोनों के लिए

थ्रेड 1 :: कॉल करने योग्य => फ़ंक्शन पॉइंटर
थ्रेड 1 :: कॉल करने योग्य => फ़ंक्शन पॉइंटर
थ्रेड 3 :: कॉल करने योग्य => लैम्ब्डा अभिव्यक्ति
थ्रेड 3 :: कॉल करने योग्य => लैम्ब्डा अभिव्यक्ति
थ्रेड 2 :: कॉल करने योग्य => फ़ंक्शन ऑब्जेक्ट
थ्रेड 2 :: कॉल करने योग्य => फ़ंक्शन ऑब्जेक्ट

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

अनुशंसित पढ़ना = >> थ्रेड टेस्टिंग गाइड

निष्कर्ष

इस ट्यूटोरियल में, हमने C ++ में बहुस्तरीय अवधारणाओं को स्पष्ट उदाहरण के साथ देखा है। हमारे बाद के ट्यूटोरियल में, हम और अधिक सी + + विषय सीखेंगे जो हमें मजबूत और कुशल कार्यक्रम लिखने में मदद करेंगे।

=> आसान सी ++ प्रशिक्षण श्रृंखला के माध्यम से पढ़ें।

अनुशंसित पाठ

^