पायथन अतुल्यकालिक प्रोग्रामिंग: एक संक्षिप्त अवलोकन

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



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

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

यदि आप एक किताब पढ़ रहे हैं और कोई और आपको दूसरी पुस्तक दे रहा है, तो आप इस दूसरी पुस्तक को ले सकते हैं और इसे पढ़ना शुरू कर सकते हैं। लेकिन पहले स्थगित करना होगा। बहु-थ्रेडेड कोड निष्पादन उसी सिद्धांत पर व्यवस्थित होता है। और यदि आपकी कई प्रतियाँ एक साथ कई पुस्तकें पढ़ती हैं, तो यह मल्टीप्रोसेसर सिस्टम के काम करने के समान होगा।

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

पायथन एसिंक्रोनस प्रोग्रामिंग

प्रारंभ में, पायथन ने असिंक्रोनस प्रोग्रामिंग कार्यों को हल करने के लिए जनरेटर-आधारित कोरटाइन का उपयोग किया। फिर, पायथन 3.4 में, asyncio मॉड्यूल asyncio (कभी-कभी इसका नाम async IO रूप में लिखा गया है), जो अतुल्यकालिक प्रोग्रामिंग तंत्र को लागू करता है। पायथन 3.5 ने एसिंक्स / वेट निर्माण की शुरुआत की।

अजगर में अतुल्यकालिक विकास करने के लिए, आपको कुछ अवधारणाओं से निपटने की आवश्यकता है। ये कोरटाइन और टास्क हैं।

Korutiny

आमतौर पर, coroutine एक async फ़ंक्शन है। Coroutine एक coroutine फ़ंक्शन से दी गई वस्तु भी हो सकती है।

यदि, एक फ़ंक्शन की घोषणा करते समय, यह इंगित किया जाता है कि यह अतुल्यकालिक है, तो आप इसे await कीवर्ड का उपयोग करके कॉल कर सकते हैं:

 await say_after(1, 'hello') 

इस तरह के एक निर्माण का मतलब है कि कार्यक्रम को तब तक निष्पादित किया जाएगा जब तक कि यह एक प्रतीक्षित अभिव्यक्ति का सामना नहीं करता है, जिसके बाद यह फ़ंक्शन को कॉल करेगा और तब तक अपने निष्पादन को रोक देगा जब तक कि फ़ंक्शन को पूरा नहीं किया जाता है। उसके बाद, अन्य coroutines भी शुरू करने में सक्षम होंगे।

एक कार्यक्रम को रोकने का मतलब है कि घटना लूप पर रिटर्न नियंत्रित करता है। asyncio मॉड्यूल का उपयोग करते asyncio , ईवेंट लूप सभी अतुल्यकालिक कार्यों को करता है, I / O को निष्पादित करता है, और asyncio करता है। ज्यादातर मामलों में, कार्यों को कॉरटिन चलाने के लिए उपयोग किया जाता है।

कार्य

कार्य आपको ईवेंट लूप में कोरआउट्स चलाने की अनुमति देता है। यह कई कोरटाइन के निष्पादन नियंत्रण को सरल करता है। यहां एक उदाहरण दिया गया है जो कोरटाइन और कार्यों का उपयोग करता है। ध्यान दें कि async def कंस्ट्रक्शन का उपयोग करते हुए घोषित की गई संस्थाएं कोरआउट हैं। यह उदाहरण आधिकारिक पायथन प्रलेखन से लिया गया है।

 import asyncio import time async def say_after(delay, what):    await asyncio.sleep(delay)    print(what) async def main():    task1 = asyncio.create_task(        say_after(1, 'hello'))    task2 = asyncio.create_task(        say_after(2, 'world'))    print(f"started at {time.strftime('%X')}")    #     (      #  2 .)    await task1    await task2    print(f"finished at {time.strftime('%X')}") asyncio.run(main()) 

say_after() फ़ंक्शन में async उपसर्ग है; परिणामस्वरूप, हमारे पास coroutine है। यदि हम इस उदाहरण से थोड़ा पीछे हटते हैं, तो हम कह सकते हैं कि इस फ़ंक्शन को इस तरह कहा जा सकता है:

     await say_after(1, 'hello')    await say_after(2, 'world') 

इस दृष्टिकोण के साथ, हालांकि, कोरआउट को क्रमिक रूप से लागू किया जाता है और पूरा होने में लगभग 3 सेकंड लगते हैं। हमारे उदाहरण में, वे प्रतिस्पर्धी रूप से लॉन्च किए गए हैं। उनमें से प्रत्येक के लिए एक कार्य का उपयोग किया जाता है। नतीजतन, पूरे कार्यक्रम का निष्पादन समय लगभग 2 सेकंड है। कृपया ध्यान दें कि काम करने के लिए इस तरह के कार्यक्रम के लिए, यह केवल async साथ main() फ़ंक्शन को घोषित करने के लिए पर्याप्त नहीं है। ऐसी स्थितियों में, आपको asyncio मॉड्यूल का उपयोग करने की आवश्यकता है।

यदि आप उदाहरण कोड चलाते हैं, तो स्क्रीन पर निम्न के समान एक पाठ प्रदर्शित किया जाएगा:

 started at 20:19:39 hello world finished at 20:19:41 

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

उदाहरण

इस उदाहरण में, संख्याओं के अनुक्रम के दस तत्वों की राशि की गणना करने के लिए आवश्यक संचालन की संख्या निर्धारित की जाती है। अनुक्रम के अंत से गणना शुरू की जाती है। एक पुनरावर्ती कार्य 10 नंबर प्राप्त करके शुरू होता है, फिर 9 और 8 नंबर के साथ खुद को कॉल करता है, जो जोड़कर वापस आ जाएगा। यह तब तक जारी रहता है जब तक गणना पूरी नहीं हो जाती। नतीजतन, यह पता चला है, उदाहरण के लिए कि 1 से 10 तक संख्याओं के अनुक्रम का योग 55 है। इसी समय, हमारा कार्य बहुत अक्षम है, यहां time.sleep(0.1) निर्माण का उपयोग किया जाता है।

यहाँ फ़ंक्शन कोड है:

 import time def fib(n):    global count    count=count+1    time.sleep(0.1)    if n > 1:        return fib(n-1) + fib(n-2)    return n start=time.time() global count count = 0 result = fib(10) print(result,count) print(time.time()-start) 

यदि आप अतुल्यकालिक तंत्रों का उपयोग करके इस कोड को फिर से लिखते हैं और asyncio.gather निर्माण लागू करते asyncio.gather , तो क्या होता asyncio.gather , जो दो कार्यों को करने और उन्हें पूरा करने के लिए इंतजार करने के लिए जिम्मेदार है?

 import asyncio,time async def fib(n):    global count    count=count+1    time.sleep(0.1)    event_loop = asyncio.get_event_loop()    if n > 1:        task1 = asyncio.create_task(fib(n-1))        task2 = asyncio.create_task(fib(n-2))        await asyncio.gather(task1,task2)        return task1.result()+task2.result()    return n 

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

परिणाम

ऐसी स्थितियाँ हैं जिनमें कार्यों और कॉरटीन का उपयोग बहुत उपयोगी है। उदाहरण के लिए, यदि किसी प्रोग्राम में इनपुट-आउटपुट और गणनाओं का मिश्रण होता है, या यदि एक ही प्रोग्राम में अलग-अलग गणनाएँ की जाती हैं, तो आप इन समस्याओं को एक प्रतियोगी की बजाय कोड चलाकर हल कर सकते हैं। अनुक्रमिक मोड में। यह कार्यक्रम के लिए कुछ क्रियाओं को करने के लिए आवश्यक समय को कम करने में मदद करता है। हालांकि, यह अनुमति नहीं देता है, उदाहरण के लिए, एक साथ गणना करने के लिए। ऐसी गणनाओं को व्यवस्थित करने के लिए मल्टीप्रोसेसिंग का उपयोग किया जाता है। यह एक अलग बड़ा विषय है।

प्रिय पाठकों! आप अतुल्यकालिक पायथन कोड कैसे लिखते हैं?