🧗🏻 👨‍👨‍👧‍👦 🙅 पायथन 3.5 एस्किंसीओ का उपयोग कर कंज्यूर को लागू करना 🈺 🖖🏽 🤟🏾

अध्याय 13 का अनुवाद संगति
'विशेषज्ञ पायथन प्रोग्रामिंग' पुस्तक से,
दूसरा संस्करण
मिशैल जॉर्स्की और तारेक ज़िआदे, 2016

अतुल्यकालिक प्रोग्रामिंग

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

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

लेकिन, निश्चित रूप से, हम एक अतुल्यकालिक कार्यक्रम में कार्यों के समानांतर प्रसंस्करण के लिए थ्रेड्स का उपयोग नहीं करते हैं। अधिकांश समाधान अलग-अलग अवधारणाओं का उपयोग करते हैं और कार्यान्वयन के आधार पर, अलग-अलग कहा जाता है। ऐसे समानांतर कार्यक्रम वस्तुओं का वर्णन करने के लिए उपयोग किए जाने वाले नामों के कुछ उदाहरण हैं:

ग्रीन थ्रेड्स - ग्रीन थ्रेड्स (ग्रीनलेट, जेंटेन या इवेंटलेट प्रोजेक्ट्स)
कोरआउट्स - कोरआउट (पायथन 3.5 में शुद्ध अतुल्यकालिक प्रोग्रामिंग)
टास्कलेट्स (स्टैकलेस पायथन) ये मूल रूप से एक ही अवधारणाएं हैं, लेकिन अक्सर थोड़े अलग तरीकों से लागू की जाती हैं।

स्पष्ट कारणों के लिए, इस खंड में हम केवल उन कोराउटाइनों पर ध्यान केंद्रित करेंगे जो शुरू में पायथन द्वारा समर्थित हैं, जो कि संस्करण 3.5 से शुरू होता है।

सहयोगी मल्टीटास्किंग और एसिंक्रोनस I / O

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

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

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

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

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

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

पायथन async और खोजशब्दों का इंतजार है

एसिंक्रोनस और वेइट के कीवर्ड एसिंक्रोनस पायथन प्रोग्रामिंग में मुख्य बिल्डिंग ब्लॉक हैं।

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

async def async_hello(): print("hello, world!")

Async कीवर्ड का उपयोग करके परिभाषित कार्य विशेष हैं। जब बुलाया जाता है, तो वे अंदर कोड निष्पादित नहीं करते हैं, बल्कि एक coroutine ऑब्जेक्ट लौटाते हैं:

 >>>> async def async_hello(): ... print("hello, world!") ... >>> async_hello() <coroutine object async_hello at 0x1014129e8>

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

 >>> import asyncio >>> async def async_hello(): ... print("hello, world!") ... >>> loop = asyncio.get_event_loop() >>> loop.run_until_complete(async_hello()) hello, world! >>> loop.close()

स्वाभाविक रूप से, हमारे कार्यक्रम में केवल एक सरल कॉरआउट बनाया जाता है, हम समानता को लागू नहीं करते हैं। वास्तव में कुछ समानांतर देखने के लिए, हमें और अधिक कार्य बनाने की आवश्यकता है जो एक ईवेंट लूप द्वारा किया जाएगा।

नए कार्यों को लूप में जोड़ा जा सकता है। loop.create_task () विधि को कॉल करके या asyncio.wait () फ़ंक्शन का उपयोग करने के लिए प्रतीक्षा करने के लिए कोई अन्य ऑब्जेक्ट प्रदान करके। हम बाद के दृष्टिकोण का उपयोग करेंगे और रेंज () फ़ंक्शन का उपयोग करके उत्पन्न संख्याओं के अनुक्रम को अतुल्यकालिक रूप से प्रिंट करने का प्रयास करेंगे:

 import asyncio async def print_number(number): print(number) if __name__ == "__main__": loop = asyncio.get_event_loop() loop.run_until_complete( asyncio.wait([ print_number(number) for number in range(10) ]) ) loop.close()

Asyncio.wait () फ़ंक्शन कोरटाइन ऑब्जेक्ट्स की एक सूची को स्वीकार करता है और तुरंत लौटता है। परिणाम एक जनरेटर है जो भविष्य के परिणामों (वायदा) का प्रतिनिधित्व करने वाली वस्तुओं का उत्पादन करता है। जैसा कि नाम से पता चलता है, इसका उपयोग सभी प्रदान किए गए कोरआउट को पूरा करने के लिए प्रतीक्षा करने के लिए किया जाता है। कॉरटीन ऑब्जेक्ट के बजाय एक जनरेटर को वापस करने का कारण यह है कि यह पायथन के पिछले संस्करणों के साथ पीछे की ओर संगत है, जिसे बाद में समझाया जाएगा। इस लिपि को निष्पादित करने का परिणाम निम्नानुसार हो सकता है:

 $ python asyncprint.py 0 7 8 3 9 4 1 5 2 6

जैसा कि हम देख सकते हैं, संख्याएँ उस क्रम में नहीं छपी हैं, जिसमें हमने अपनी कोरटाइन्स बनाई थीं। लेकिन यह वही है जो हम हासिल करना चाहते थे।

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

मान लें कि हम दो कोरटाइन्स बनाना चाहते हैं जो लूप में कुछ सरल कार्य करेंगे:

सेकंड के एक यादृच्छिक संख्या की प्रतीक्षा करें
एक तर्क के रूप में दिए गए कुछ पाठ को प्रिंट करें, और प्रतीक्षा में बिताए समय की मात्रा। आइए एक सरल कार्यान्वयन से शुरू करें जिसमें कुछ समसामयिक मुद्दे हैं जिन्हें हम बाद में प्रतीक्षा के अतिरिक्त उपयोग के साथ सुधारने का प्रयास करेंगे:
```
 import time import random import asyncio async def waiter(name): for _ in range(4): time_to_sleep = random.randint(1, 3) / 4 time.sleep(time_to_sleep) print( "{} waited {} seconds" "".format(name, time_to_sleep) ) async def main(): await asyncio.wait([waiter("foo"), waiter("bar")]) if __name__ == "__main__": loop = asyncio.get_event_loop() loop.run_until_complete(main()) loop.close() 
```

जब टर्मिनल में निष्पादित किया जाता है (समय को मापने के लिए समय कमांड का उपयोग करके), आप देख सकते हैं:

 $ time python corowait.py bar waited 0.25 seconds bar waited 0.25 seconds bar waited 0.5 seconds bar waited 0.5 seconds foo waited 0.75 seconds foo waited 0.75 seconds foo waited 0.25 seconds foo waited 0.25 seconds real 0m3.734s user 0m0.153s sys 0m0.028s

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

इसका उत्तर asyncio.sleep () का उपयोग करना है , जो time.sleep () का एक अतुल्यकालिक संस्करण है, और प्रतीक्षित कीवर्ड का उपयोग करके परिणाम की अपेक्षा करता है। हमने पहले से ही मुख्य () के पहले संस्करण में इस कथन का उपयोग किया था, लेकिन यह केवल कोड की स्पष्टता में सुधार करना था। इसने स्पष्ट रूप से हमारे कार्यान्वयन को अधिक समानांतर नहीं बनाया। आइए वेटर के सुधारित संस्करण पर नज़र डालें () coroutine जो वेट का उपयोग करता है asyncio.sleep ():

 async def waiter(name): for _ in range(4): time_to_sleep = random.randint(1, 3) / 4 await asyncio.sleep(time_to_sleep) print( "{} waited {} seconds" "".format(name, time_to_sleep) )

अपडेट की गई स्क्रिप्ट को चलाने पर, हम देखेंगे कि दो फंक्शन्स का आउटपुट एक-दूसरे के साथ कैसे होता है:

 $ time python corowait_improved.py bar waited 0.25 seconds foo waited 0.25 seconds bar waited 0.25 seconds foo waited 0.5 seconds foo waited 0.25 seconds bar waited 0.75 seconds foo waited 0.25 seconds bar waited 0.5 seconds real 0m1.953s user 0m0.149s sys 0m0.026s

इस सरल सुधार का एक अतिरिक्त लाभ यह है कि कोड तेजी से चलता है। कुल निष्पादन का समय सभी नींद के समय की तुलना में कम था, क्योंकि कोरटाइन ने एक-एक करके नियंत्रण लिया।

पायथन के पिछले संस्करणों में एसिंसीओ

Asyncio मॉड्यूल Python 3.4 में दिखाई दिया। तो यह पायथन का एकमात्र संस्करण है जिसे पायथन 3.5 से पहले अतुल्यकालिक प्रोग्रामिंग के लिए गंभीर समर्थन प्राप्त है। दुर्भाग्य से, ऐसा लगता है कि ये दो बाद के संस्करण संगतता मुद्दों को पेश करने के लिए पर्याप्त हैं।

वैसे भी, पायथन में अतुल्यकालिक प्रोग्रामिंग कोर इस टेम्पलेट का समर्थन करने वाले सिंटैक्स तत्वों की तुलना में पहले पेश किया गया था। देर से कभी नहीं से बेहतर है, लेकिन इसने एक ऐसी स्थिति बनाई जहां कोरटाइन के साथ काम करने के लिए दो वाक्यविन्यास हैं।

पायथन 3.5 के साथ शुरू, आप एसिंक्स और वेट का उपयोग कर सकते हैं:

 async def main (): await asyncio.sleep(0)

हालाँकि, Python 3.4 में, आपको इसके अलावा asyncio.coroutine डेकोरेटर को लागू करना होगा और coroutine पाठ में उपज देना होगा:

 @asyncio.couroutine def main(): yield from asyncio.sleep(0)

एक अन्य उपयोगी तथ्य यह है कि बयान से उपज 3.3 पायथन में पेश की गई थी, और PyPI में एक अतुल्यकालिक बैकपोर्ट है। इसका मतलब है कि आप पायथन 3.3 के साथ सहयोगी मल्टीटास्किंग के इस कार्यान्वयन का उपयोग कर सकते हैं।

अतुल्यकालिक प्रोग्रामिंग का एक व्यावहारिक उदाहरण

जैसा कि इस अध्याय में कई बार उल्लेख किया गया है, अतुल्यकालिक प्रोग्रामिंग I / O को संभालने के लिए एक महान उपकरण है। यह सिर्फ मुद्रण अनुक्रम या अतुल्यकालिक प्रतीक्षा की तुलना में कुछ अधिक व्यावहारिक बनाने का समय है।

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

अजगर-गमप के निर्माता थोड़े आलसी थे और केवल नाम लेते थे। विकास को सरल बनाने के लिए, उन्होंने अपने HTTP क्लाइंट लाइब्रेरी के रूप में अनुरोध पैकेज चुना। दुर्भाग्य से, अनुरोध एसिंक्रोनस I / O को async और प्रतीक्षा के साथ समर्थन नहीं करते हैं। कुछ अन्य परियोजनाएं हैं, जिनका उद्देश्य क्वेरी प्रोजेक्ट के लिए कुछ समानता प्रदान करना है, लेकिन वे या तो जीवेंट ( grequests , https://github.com/ kennethreitz / grequests देखें ) पर निर्भर हैं या एक थ्रेड / प्रक्रिया पूल (क्वेरी-वायदा) चलाते हैं github.com/ross/requests-futures ) का संदर्भ लें। उनमें से कोई भी हमारी समस्या का हल नहीं करता है।

एक निर्दोष ओपन सोर्स डेवलपर को डांटने के लिए खुद को फटकारने से पहले, शांत हो जाओ। अजगर-gmaps पैकेज के पीछे का व्यक्ति मैं हूं। निर्भरता का एक खराब विकल्प इस परियोजना की समस्याओं में से एक है। मैं समय-समय पर सार्वजनिक रूप से खुद की आलोचना करना पसंद करता हूं। यह मेरे लिए एक कड़वा सबक होगा, क्योंकि इसके नवीनतम संस्करण में अजगर-gmaps (इस पुस्तक को लिखने के समय 0.3.1) को आसानी से अजगर के अतुल्यकालिक I / O के साथ एकीकृत नहीं किया जा सकता है। किसी भी मामले में, यह भविष्य में बदल सकता है, इसलिए कुछ भी नहीं खोया है।

पुस्तकालय की सीमाओं को जानना, जो पिछले उदाहरणों में उपयोग करना बहुत आसान था, हमें कुछ ऐसा बनाने की आवश्यकता है जो इस अंतर को भर दे। Google MapsAPI का उपयोग करना वास्तव में आसान है, इसलिए हम चित्रण के लिए एक अतुल्यकालिक उपयोगिता को कोड़ा मार देंगे। पायथन 3.5 के मानक पुस्तकालय में अभी भी एक पुस्तकालय का अभाव है जो अतुल्यकालिक HTTP अनुरोधों को आसानी से urllib.urlopen () कहते हुए निष्पादित कर सकता है। हम निश्चित रूप से खरोंच से पूर्ण प्रोटोकॉल समर्थन नहीं बनाना चाहते हैं, इसलिए हम PyPI में उपलब्ध aiohttp पैकेज से थोड़ी मदद का उपयोग करेंगे। यह वास्तव में आशाजनक पुस्तकालय है जो एसिंक्रोनस HTTP के लिए क्लाइंट और सर्वर कार्यान्वयन दोनों को जोड़ता है। यहाँ aiohttp के शीर्ष पर एक छोटा मॉड्यूल बनाया गया है जो एक जियोकोड () सहायक फ़ंक्शन बनाता है जो Google मैप्स एपीआई सेवा के लिए जियोकोडिंग अनुरोधों को निष्पादित करता है:

 import aiohttp session = aiohttp.ClientSession() async def geocode(place): params = { 'sensor': 'false', 'address': place } async with session.get( 'https://maps.googleapis.com/maps/api/geocode/json', params=params ) as response: result = await response.json() return result['results']

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

Fetch_place () फ़ंक्शन का उपयोग करके समानांतर में बाहरी सेवा के लिए सभी अनुरोधों को पूरा करें।
Present_result () फ़ंक्शन का उपयोग करके लूप में सभी परिणाम प्रदर्शित करें।

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

 import asyncio # note: local module introduced earlier from asyncgmaps import geocode, session PLACES = ( 'Reykjavik', 'Vien', 'Zadar', 'Venice', 'Wrocław', 'Bolognia', 'Berlin', 'Słubice', 'New York', 'Dehli', ) async def fetch_place(place): return (await geocode(place))[0] async def present_result(result): geocoded = await result print("{:>25s}, {:6.2f}, {:6.2f}".format( geocoded['formatted_address'], geocoded['geometry']['location']['lat'], geocoded['geometry']['location']['lng'], )) async def main(): await asyncio.wait([ present_result(fetch_place(place)) for place in PLACES ]) if __name__ == "__main__": loop = asyncio.get_event_loop() loop.run_until_complete(main()) # aiohttp will raise issue about unclosed # ClientSession so we perform cleanup manually loop.run_until_complete(session.close()) loop.close()

अतुल्यकालिक प्रोग्रामिंग स्केलेबल अनुप्रयोगों के निर्माण में रुचि रखने वाले बैकेंड डेवलपर्स के लिए बहुत अच्छा है। व्यवहार में, यह अत्यधिक प्रतिस्पर्धी सर्वर बनाने के लिए सबसे महत्वपूर्ण उपकरणों में से एक है।

लेकिन वास्तविकता दुखद है। कई लोकप्रिय पैकेज जो I / O समस्याओं से निपटते हैं, उनका उपयोग अतुल्यकालिक कोड के साथ करने का इरादा नहीं है। इसके मुख्य कारण हैं:

अभी भी पायथन 3 का कम कार्यान्वयन और इसकी कुछ उन्नत विशेषताएं हैं
पायथन सीखने के लिए शुरुआती लोगों के बीच विभिन्न संगामिति अवधारणाओं की कम समझ

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

एक और समस्या लंबे समय तक प्रोसेसर-बाउंड ऑपरेशन है। जब आप एक I / O ऑपरेशन करते हैं, तो एक coroutine से नियंत्रण जारी करने में कोई समस्या नहीं है। फ़ाइल सिस्टम या सॉकेट से लिखते / पढ़ते समय, आप अंततः प्रतीक्षा करेंगे, इसलिए प्रतीक्षा का उपयोग करते हुए एक कॉल सबसे अच्छा है जो आप कर सकते हैं। लेकिन क्या होगा अगर आपको कुछ गणना करने की आवश्यकता है, और आप जानते हैं कि इसमें कुछ समय लगेगा? बेशक, आप समस्या को भागों में विभाजित कर सकते हैं और हर बार जब आप काम को थोड़ा आगे बढ़ाते हैं तो नियंत्रण को रद्द कर सकते हैं। लेकिन जल्द ही आप पाएंगे कि यह बहुत अच्छा मॉडल नहीं है। ऐसी चीज कोड को गड़बड़ कर सकती है, और अच्छे परिणामों की गारंटी भी नहीं देती है।

टेम्पोरल बाइंडिंग दुभाषिया या ऑपरेटिंग सिस्टम की जिम्मेदारी होनी चाहिए।

एसिंक्रोनस फ्यूचर्स के साथ एसिंक्रोनस कोड का संयोजन

तो क्या करें यदि आपके पास कोड है जो लंबे समय तक तुल्यकालिक I / O करता है जिसे आप फिर से लिखना नहीं चाहते हैं या नहीं कर सकते हैं। या क्या करना है जब आपको मुख्य रूप से अतुल्यकालिक I / O के लिए डिज़ाइन किए गए एप्लिकेशन में कुछ भारी प्रोसेसर संचालन करना पड़ता है? खैर ... आपको वर्कअराउंड खोजने की आवश्यकता है। और इससे मेरा मतलब है कि मल्टीथ्रेडिंग या मल्टीप्रोसेसिंग।

यह बहुत अच्छा नहीं लग सकता है, लेकिन कभी-कभी सबसे अच्छा समाधान वह हो सकता है जिसे हमने दूर करने की कोशिश की। पायथन में संसाधन-गहन कार्यों के समानांतर प्रसंस्करण को हमेशा मल्टीप्रोसेसिंग के कारण बेहतर प्रदर्शन किया जाता है। और मल्टीथ्रेडिंग I / O संचालन को समान रूप से अच्छी तरह से (जल्दी और बहुत सारे संसाधनों के बिना) संभाल सकता है, अतुल्यकालिक और प्रतीक्षा के रूप में अगर ठीक से कॉन्फ़िगर और देखभाल के साथ संभाला जाए।

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

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

निष्पादनकर्ता और वायदा

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

समवर्ती.फुटर्स मॉड्यूल में सबसे महत्वपूर्ण कक्षाएं एक्ज़ीक्यूटर और फ्यूचर हैं ।

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

ThreadPoolExecutor : जो थ्रेड पूल का प्रतिनिधित्व करता है
ProcessPoolExecutor : जो एक प्रक्रिया पूल का प्रतिनिधित्व करता है

प्रत्येक निष्पादक तीन तरीके प्रस्तुत करता है:

सबमिट करें (fn, * args, ** kwargs) : संसाधन पूल में निष्पादित करने के लिए fn फ़ंक्शन को शेड्यूल करता है और एक फ्यूचर ऑब्जेक्ट को रिटर्न ऑब्जेक्ट के निष्पादन का प्रतिनिधित्व करता है।
नक्शा (func, * iterables, timeout = कोई नहीं, chunksize = 1) : func फ़ंक्शन को मल्टीप्रोसेसिंग के समान पुनरावृति पर निष्पादित किया जाता है। पूल.मैप () विधि
शटडाउन (प्रतीक्षा = सत्य) : यह एक्ज़ेक्यूटर को बंद कर देता है और उसके सभी संसाधनों को मुक्त कर देता है।

सबसे दिलचस्प तरीका भविष्य की वस्तु के कारण जमा () है जो इसे लौटाता है। यह कॉल के अतुल्यकालिक निष्पादन का प्रतिनिधित्व करता है और केवल अप्रत्यक्ष रूप से इसके परिणाम का प्रतिनिधित्व करता है। प्रेषण ऑब्जेक्ट का वास्तविक रिटर्न मान प्राप्त करने के लिए, आपको Future.result () विधि को कॉल करना होगा। और अगर तथाकथित ऑब्जेक्ट पहले से ही पूरा हो गया है, तो परिणाम () विधि इसे ब्लॉक नहीं करेगी और बस फ़ंक्शन के आउटपुट को वापस कर देगी। यदि ऐसा नहीं है, तो वह परिणाम तैयार होने तक इसे रोक देगा। इसे परिणाम के वादे के रूप में सोचें (यह वास्तव में जावास्क्रिप्ट में वादे के समान अवधारणा है)। आपको इसे प्राप्त करने के तुरंत बाद इसे अनपैक करने की आवश्यकता नहीं है ( परिणाम () विधि का उपयोग करके), लेकिन यदि आप ऐसा करने का प्रयास करते हैं, तो अंततः कुछ वापस करने की गारंटी है:

 >>> def loudy_return(): ... print("processing") ... return 42 ... >>> from concurrent.futures import ThreadPoolExecutor >>> with ThreadPoolExecutor(1) as executor: ... future = executor.submit(loudy_return) ... processing >>> future <Future at 0x33cbf98 state=finished returned int> >>> future.result() 42

यदि आप Executor.map () विधि का उपयोग करना चाहते हैं, तो यह मल्टीप्रोसेसर मॉड्यूल के पूल वर्ग के पूल.मैप () विधि से उपयोग में भिन्न नहीं है:

 def main(): with ThreadPoolExecutor(POOL_SIZE) as pool: results = pool.map(fetch_place, PLACES) for result in results: present_result(result)

ईवेंट लूप में निष्पादनकर्ता का उपयोग करना

Executor.submit () विधि द्वारा लौटाए गए भविष्य के वर्ग के उदाहरण वैचारिक रूप से अतुल्यकालिक प्रोग्रामिंग में उपयोग किए गए कोरआउट के बहुत करीब हैं। इसलिए हम सहयोगात्मक मल्टीटास्किंग और मल्टीप्रोसेसिंग या मल्टीथ्रेडिंग के बीच हाइब्रिड बनाने के लिए कलाकारों का उपयोग कर सकते हैं।

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

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

तो, चलिए मान लेते हैं कि हम अजगर-गैमैप पैकेज के समस्याग्रस्त हिस्से को फिर से लिखना नहीं चाहते थे जो कि आपके सिरदर्द का कारण बन रहा था। हम अपेक्षित कॉरटीन के रूप में fetch_place () फ़ंक्शन को छोड़ते हुए, लूप.run_in_executor () को कॉल करके एक अलग थ्रेड को आसानी से रोक सकते हैं।

 async def fetch_place(place): coro = loop.run_in_executor(None, api.geocode, place) result = await coro return result[0]

ऐसा समाधान काम करने के लिए पूरी तरह से अतुल्यकालिक पुस्तकालय होने से भी बदतर है, लेकिन आप जानते हैं कि कम से कम कुछ भी नहीं से बेहतर है।

यह समझने के बाद कि वास्तव में क्या संगामिति है, हमने कार्रवाई की और मल्टीथ्रेडिंग का उपयोग करते हुए विशिष्ट समानांतर समस्याओं में से एक का विश्लेषण किया। हमारे कोड की मुख्य कमियों की पहचान करने और उन्हें ठीक करने के बाद, हम यह देखने के लिए बहुसंस्कृति में बदल गए कि यह हमारे मामले में कैसे काम करेगा।

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

समस्या को दूर करने की बात करते हुए, हमने अंततः अतुल्यकालिक प्रोग्रामिंग की कोशिश की, जो कि I / O संबंधित अनुप्रयोगों के लिए सबसे अच्छा समाधान होना चाहिए, केवल यह समझने के लिए कि हम थ्रेड्स और प्रक्रियाओं के बारे में पूरी तरह से नहीं भूल सकते। इसलिए हमने एक वृत्त बनाया, जहाँ से हमने शुरुआत की थी!

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

पिछला निष्कर्ष अगले अध्याय, अध्याय 14 "उपयोगी डिज़ाइन पैटर्न" के विषय का एक उत्कृष्ट परिचय है। चूंकि एक भी टेम्पलेट नहीं है जो आपकी सभी समस्याओं को हल करेगा। आपको यथासंभव पता होना चाहिए, क्योंकि अंततः आप हर दिन उनका उपयोग करेंगे।

पायथन 3.5 एस्किंसीओ का उपयोग कर कंज्यूर को लागू करना