पायथन मल्टीप्रोसेसिंग फॉर-लूप

मल्टीप्रोसेसिंग की तुलना मल्टीथ्रेडिंग से की जा सकती है। हालाँकि, यह इस बात में अंतर करता है कि थ्रेडिंग के लिए नियोजित GIL के कारण हम एक समय में केवल एक थ्रेड को निष्पादित कर सकते हैं। मल्टीप्रोसेसिंग कई CPU कोर में क्रमिक रूप से संचालन करने की प्रक्रिया है। थ्रेड को समानांतर में संचालित नहीं किया जा सकता है। हालांकि, मल्टीप्रोसेसिंग हमें प्रक्रियाओं को स्थापित करने और उन्हें विभिन्न CPU कोर पर एक साथ चलाने की अनुमति देता है। लूप, जैसे फॉर-लूप, सबसे अधिक उपयोग की जाने वाली स्क्रिप्टिंग भाषाओं में से एक है। विभिन्न डेटा का उपयोग करते हुए एक ही कार्य को तब तक दोहराएं जब तक कि एक मानदंड, जैसे पुनरावृत्तियों की पूर्व निर्धारित संख्या, तक नहीं पहुंच जाता। लूप प्रत्येक पुनरावृत्ति को एक-एक करके पूरा करता है।

उदाहरण 1: पायथन मल्टीप्रोसेसिंग मॉड्यूल में फॉर-लूप का उपयोग करना

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

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

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

अगला, हम 'func' नामक एक उपयोगकर्ता-परिभाषित फ़ंक्शन को परिभाषित करते हैं। चूंकि यह उपयोगकर्ता परिभाषित कार्य है, इसलिए हम इसे अपनी पसंद का नाम देते हैं। इस फ़ंक्शन के मुख्य भाग के अंदर, हम 'विषय' चर को तर्क और 'गणित' मान के रूप में पास करते हैं। अगला, हम 'प्रिंट ()' फ़ंक्शन को कॉल करते हैं, 'सामान्य विषय का नाम है' और साथ ही इसके 'विषय' तर्क को पास करते हैं जिसमें मूल्य होता है। फिर, अगले चरण में, हम 'अगर नाम == _मुख्य_' का उपयोग करते हैं, जो फ़ाइल को मॉड्यूल के रूप में आयात किए जाने पर आपको कोड चलाने से रोकता है और केवल तभी ऐसा करने की अनुमति देता है जब सामग्री को स्क्रिप्ट के रूप में निष्पादित किया जाता है।

आप जिस कंडीशन सेक्शन से शुरू करते हैं, उसे ज्यादातर परिस्थितियों में सामग्री प्रदान करने के लिए एक स्थान के रूप में माना जा सकता है, जिसे केवल तभी निष्पादित किया जाना चाहिए जब आपकी फ़ाइल स्क्रिप्ट के रूप में चलती है। फिर, हम तर्क विषय का उपयोग करते हैं और इसमें कुछ मान संग्रहीत करते हैं जो 'विज्ञान', 'अंग्रेजी' और 'कंप्यूटर' हैं। प्रक्रिया को निम्नलिखित चरण में 'प्रक्रिया 1 []' नाम दिया गया है। फिर, हम प्रक्रिया में फ़ंक्शन को कॉल करने के लिए 'प्रक्रिया (लक्ष्य = func)' का उपयोग करते हैं। फ़ंक्शन को कॉल करने के लिए लक्ष्य का उपयोग किया जाता है, और हम इस प्रक्रिया को 'पी' चर में सहेजते हैं।

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

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

उदाहरण 2: अनुक्रमिक फॉर-लूप का मल्टीप्रोसेसिंग समानांतर फॉर-लूप में रूपांतरण

इस उदाहरण में, मल्टीप्रोसेसिंग लूप टास्क को समानांतर फॉर-लूप टास्क में बदलने से पहले क्रमिक रूप से निष्पादित किया जाता है। आप फ़ॉर-लूप का उपयोग करके संग्रह या स्ट्रिंग जैसे अनुक्रमों के माध्यम से चक्रित कर सकते हैं।

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

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

अब आप देख सकते हैं कि जब हम कोड निष्पादित करते हैं, तो लूप फ़ंक्शन को '10' बार चलाने का कारण बनता है। यह 10 बार दोहराता है, सूचकांक शून्य से शुरू होता है और सूचकांक नौ पर समाप्त होता है। प्रत्येक संदेश में एक कार्य संख्या होती है जो एक फ़ंक्शन संख्या होती है जिसे हम 'आर्ग' और एक निर्माण संख्या के रूप में पास करते हैं।

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

फिर, एक संदेश दिखाने के लिए 'प्रिंट ()' विधि को लागू करने और थोड़ी देर की देरी के लिए 'वैल' पैरामीटर देने के बाद, हम प्रवेश बिंदुओं को सुरक्षित करने के लिए 'यदि नाम = मुख्य' फ़ंक्शन का उपयोग करते हैं। इसके बाद, हम एक प्रक्रिया बनाते हैं और 'प्रक्रिया' का उपयोग करके प्रक्रिया में फ़ंक्शन को कॉल करते हैं और 'लक्ष्य = func' पास करते हैं। फिर, हम 'func', 'arg' पास करते हैं, मान 'm' पास करते हैं, और '10' रेंज पास करते हैं, जिसका अर्थ है कि लूप '10' पुनरावृत्तियों के बाद फ़ंक्शन को समाप्त कर देता है। फिर, हम 'प्रक्रिया' के साथ 'प्रारंभ ()' विधि का उपयोग करके प्रक्रिया शुरू करते हैं। फिर, हम प्रक्रिया के निष्पादन की प्रतीक्षा करने और उसके बाद की सभी प्रक्रिया को पूरा करने के लिए 'जॉइन ()' विधि कहते हैं।

इसलिए, जब हम कोड निष्पादित करते हैं, तो फ़ंक्शन मुख्य प्रक्रिया को कॉल करते हैं और उनका निष्पादन शुरू करते हैं। हालाँकि, वे तब तक किए जाते हैं जब तक कि सभी कार्य पूरे नहीं हो जाते। हम इसे देख सकते हैं क्योंकि प्रत्येक कार्य समवर्ती रूप से किया जाता है। समाप्त होते ही यह अपने संदेश की रिपोर्ट करता है। इसका मतलब यह है कि यद्यपि संदेश क्रम से बाहर हैं, सभी '10' पुनरावृत्तियों के पूरा होने के बाद लूप समाप्त हो जाता है।

निष्कर्ष

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