👩🏿‍🚀 👩🏻‍🏭 👩🏿‍⚖️ एसिंक्रोनस पायथन: प्रतियोगिता के विभिन्न रूप 👍🏻 🚴🏼 😕

पायथन 3 के आगमन के साथ, "अतुल्यकालिकता" और "संगामिति" के बारे में काफी चर्चा है, हम मान सकते हैं कि पायथन ने हाल ही में इन सुविधाओं / अवधारणाओं को पेश किया है। लेकिन ऐसा है नहीं। हमने कई बार इन ऑपरेशनों का उपयोग किया है। इसके अलावा, शुरुआती सोच सकते हैं कि एसिंकोसो एसिंक्रोनस / समानांतर संचालन को फिर से बनाने और उपयोग करने का एकमात्र या सबसे अच्छा तरीका है। इस लेख में, हम समानता, उनके फायदे और नुकसान को प्राप्त करने के विभिन्न तरीकों पर ध्यान देंगे।

शब्दों की परिभाषा:

इससे पहले कि हम तकनीकी पहलुओं पर ध्यान दें, इस संदर्भ में अक्सर इस्तेमाल की जाने वाली शर्तों की कुछ बुनियादी समझ होना जरूरी है।

तुल्यकालिक और अतुल्यकालिक:

तुल्यकालिक संचालन में, कार्यों को एक के बाद एक किया जाता है। अतुल्यकालिक कार्यों में एक दूसरे से स्वतंत्र रूप से शुरू और पूरा किया जा सकता है। एक अतुल्यकालिक कार्य शुरू हो सकता है और चलना जारी रख सकता है जबकि निष्पादन एक नए कार्य के लिए चलता है। अतुल्यकालिक कार्य ब्लॉक नहीं होते हैं (कार्य को पूरा करने के लिए प्रतीक्षा करने के लिए मजबूर नहीं करते) संचालन और आमतौर पर पृष्ठभूमि में प्रदर्शन किया जाता है।

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

प्रतिस्पर्धा और संक्षिप्तता:

प्रतिस्पर्धा का तात्पर्य है कि दो कार्य संयुक्त रूप से किए जाते हैं। हमारे पिछले उदाहरण में, जब हमने अतुल्यकालिक उदाहरण पर विचार किया, तो हम धीरे-धीरे एक पत्र लिखने में आगे बढ़े, फिर एक दौरे के साथ बातचीत में। एजेंसी। यह प्रतिस्पर्धा है ।

जब हमने एक दोस्त को फोन करने के लिए कहा, और खुद एक पत्र लिखा, तो समानांतर में कार्य किए गए।

कॉन्सैरेसी अनिवार्य रूप से प्रतियोगिता का एक रूप है। लेकिन concurrency हार्डवेयर निर्भर है। उदाहरण के लिए, यदि CPU में केवल एक कोर है, तो दो कार्यों को समानांतर में निष्पादित नहीं किया जा सकता है। वे बस प्रोसेसर समय को आपस में साझा करते हैं। फिर यह प्रतियोगिता है, लेकिन संगामिति नहीं। लेकिन जब हमारे पास पिछले उदाहरण में एक दोस्त के रूप में कई कोर होते हैं , जो दूसरा कोर है, लगभग। अनुवादक] हम एक ही समय में कई ऑपरेशन (कोर की संख्या के आधार पर) कर सकते हैं।

संक्षेप में:

तुल्यकालन: ब्लॉक संचालन (अवरुद्ध)
अतुल्यकालिक: ऑपरेशन को अवरुद्ध नहीं करता है (गैर-अवरुद्ध)
प्रतिस्पर्धात्मकता: संयुक्त प्रगति (संयुक्त)
समरूपता: समानांतर प्रगति (समानांतर)

कॉनक्यूरेसी का मतलब है प्रतियोगिता। लेकिन प्रतिस्पर्धा हमेशा निर्णायक नहीं होती है।

सूत्र और प्रक्रियाएँ

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

स्ट्रीम (धागे)

एक छोटे से उदाहरण पर विचार करें। निम्न कोड में, कार्यकर्ता फ़ंक्शन असिंक्रोनस और एक साथ कई थ्रेड्स पर निष्पादित करेगा।

import threading import time import random def worker(number): sleep = random.randrange(1, 10) time.sleep(sleep) print("I am Worker {}, I slept for {} seconds".format(number, sleep)) for i in range(5): t = threading.Thread(target=worker, args=(i,)) t.start() print("All Threads are queued, let's see when they finish!")

और यहाँ एक उदाहरण आउटपुट है:

 $ python thread_test.py All Threads are queued, let's see when they finish! I am Worker 1, I slept for 1 seconds I am Worker 3, I slept for 4 seconds I am Worker 4, I slept for 5 seconds I am Worker 2, I slept for 7 seconds I am Worker 0, I slept for 9 seconds

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

हमारे उदाहरण में, हमने थ्रेड कंस्ट्रक्टर को फ़ंक्शन पास किया। यदि हम चाहते थे, तो हम एक विधि (OOP शैली) के साथ एक उपवर्ग लागू कर सकते थे।

आगे पढ़ने:

धाराओं के बारे में अधिक जानने के लिए, नीचे दिए गए लिंक का उपयोग करें:

pymotw.com/3/threading/index.html

ग्लोबल इंटरप्रेटर लॉक (GIL)

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

GIL त्वरित विवरण:

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

कई लोग जीआईएल को कमजोरी के रूप में देखते हैं। मैं इसे एक आशीर्वाद के रूप में मानता हूं, क्योंकि NumPy, SciPy जैसे पुस्तकालय बनाए गए थे, जो वैज्ञानिक समुदाय में एक विशेष, अद्वितीय स्थान पर कब्जा करते हैं।

आगे पढ़ने:

ये संसाधन आपको जीआईएल में विलंब करने की अनुमति देंगे:

प्रक्रियाओं (प्रक्रियाओं)

पायथन में संगामिति प्राप्त करने के लिए, एक मल्टीप्रोसेसिंग मॉड्यूल जोड़ा गया है जो एक एपीआई प्रदान करता है और बहुत समान दिखता है यदि आपने पहले थ्रेडिंग का उपयोग किया था।

चलिए बस पिछले उदाहरण को बदलते हैं। अब संशोधित संस्करण स्ट्रीम के बजाय प्रक्रिया का उपयोग करता है।

 import multiprocessing import time import random def worker(number): sleep = random.randrange(1, 10) time.sleep(sleep) print("I am Worker {}, I slept for {} seconds".format(number, sleep)) for i in range(5): t = multiprocessing.Process(target=worker, args=(i,)) t.start() print("All Processes are queued, let's see when they finish!")

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

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

 from multiprocessing import Pool def f(x): return x*x if __name__ == '__main__': p = Pool(5) print(p.map(f, [1, 2, 3]))

यहां, मानों की सूची पर पुनरावृत्ति करने और फ़ंक्शन एफ को एक बार में कॉल करने के बजाय, हम वास्तव में फ़ंक्शन को विभिन्न प्रक्रियाओं में चलाते हैं। एक प्रक्रिया f (1), दूसरी f (2), और दूसरी f (3) करती है। अंत में, परिणामों को फिर से एक सूची में जोड़ दिया जाता है। यह हमें भारी गणनाओं को छोटे भागों में तोड़ने और उन्हें तेज गणना के लिए समानांतर में चलाने की अनुमति देता है।

आगे पढ़ने:

pymotw.com/3/multiprocessing/index.html

समवर्ती.सुधार मॉड्यूल

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

और यहाँ एक उदाहरण है ThreadPoolExecutor:

 from concurrent.futures import ThreadPoolExecutor from time import sleep def return_after_5_secs(message): sleep(5) return message pool = ThreadPoolExecutor(3) future = pool.submit(return_after_5_secs, ("hello")) print(future.done()) sleep(5) print(future.done()) print(future.result())

मेरे पास समवर्ती .futures masnun.com/2016/03/29/python-a-quick-introduction-to-the-concurrent-futures-module.html के बारे में एक लेख है। यह इस मॉड्यूल के गहन अध्ययन के लिए उपयोगी हो सकता है।

आगे पढ़ने:

pymotw.com/3/concurrent.futures

Asyncio - क्या, कैसे और क्यों?

आपके पास शायद एक सवाल है कि पायथन समुदाय के कई लोगों के पास क्या है - एसिंको क्या नया लाता है? अतुल्यकालिक I / O का उपयोग करने का एक और तरीका क्यों था? क्या हमारे पास पहले से ही धागे और प्रक्रियाएं नहीं थीं? चलो देखते हैं!

हमें एसिंको की आवश्यकता क्यों है?

संसाधन बहुत महंगा हैं [संसाधन खपत के संदर्भ में, लगभग। अनुवादक] बनाने के लिए। इसलिए, I / O संचालन के लिए, थ्रेड्स मुख्य रूप से चुने गए हैं। हम जानते हैं कि I / O बाहरी चीजों पर निर्भर करता है - धीमे ड्राइव या अप्रिय नेटवर्क लैग्स I / O को अक्सर अप्रत्याशित बनाते हैं। अब मान लें कि हम I / O के लिए थ्रेड्स का उपयोग करते हैं। 3 धागे विभिन्न I / O कार्य करते हैं। दुभाषिया को प्रतिस्पर्धी प्रवाह के बीच स्विच करना होगा और उनमें से प्रत्येक को बदले में कुछ समय देना होगा। प्रवाह T1, T2 और T3 को कॉल करें। तीन सूत्र ने अपना I / O ऑपरेशन शुरू किया। T3 इसे पहले पूरा करता है। T2 और T1 को अभी भी I / O का इंतजार है। पायथन दुभाषिया T1 पर स्विच कर रहा है, लेकिन यह अभी भी इंतजार कर रहा है। खैर, दुभाषिया T2 पर जाता है, और दुभाषिया अभी भी इंतजार कर रहा है, और फिर T3 पर जाता है, जो तैयार है और कोड निष्पादित करता है। क्या आप इसे एक समस्या के रूप में देखते हैं?

T3 तैयार था, लेकिन दुभाषिया ने पहले T2 और T1 के बीच स्विच किया - यह स्विचिंग की लागत थी, जिसे हम टाल सकते थे अगर दुभाषिया पहले T3 पर जाता, तो सही?

एसिनो क्या है?

Asyncio हमें अन्य लूप सामान के साथ एक इवेंट लूप प्रदान करता है। इवेंट लूप I / O ईवेंट्स पर नज़र रखता है और जो कार्य तैयार हैं और I / O ऑपरेशंस की प्रतीक्षा कर रहे हैं [इवेंट लूप एक सॉफ्टवेयर निर्माण है जो आगमन की प्रतीक्षा करता है और प्रोग्राम में होने वाले ईवेंट या संदेश भेजता है, लगभग। अनुवादक] ।

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

Asyncio कार्यों को रोकने और फिर से शुरू करने के लिए जनरेटर और कोरटाइन का उपयोग करता है। आप यहाँ विवरण पढ़ सकते हैं:

Asyncio का उपयोग कैसे करें?

आरंभ करने से पहले, आइए एक उदाहरण देखें:

 import asyncio import datetime import random async def my_sleep_func(): await asyncio.sleep(random.randint(0, 5)) async def display_date(num, loop): end_time = loop.time() + 50.0 while True: print("Loop: {} Time: {}".format(num, datetime.datetime.now())) if (loop.time() + 1.0) >= end_time: break await my_sleep_func() loop = asyncio.get_event_loop() asyncio.ensure_future(display_date(1, loop)) asyncio.ensure_future(display_date(2, loop)) loop.run_forever()

ध्यान दें कि एसिंक्स / वेट सिंटैक्स पाइथन 3.5 और बाद में केवल के लिए है। कोड के माध्यम से चलते हैं:

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

जब भी प्रतीक्षा का आह्वान किया जाता है, asyncio को पता चलता है कि फ़ंक्शन को संभवतः कुछ समय लगेगा। इस प्रकार, यह निष्पादन को रोक देता है, इससे जुड़ी किसी भी I / O घटनाओं की निगरानी करना शुरू कर देता है, और आपको कार्य चलाने की अनुमति देता है। जब एसिंसीओ ने नोटिस किया कि रुका हुआ फ़ंक्शन I / O तैयार है, तो यह फ़ंक्शन को फिर से शुरू करता है।

सही चुनाव करना।

हम सिर्फ प्रतिस्पर्धा के सबसे लोकप्रिय रूपों से गुजरे। लेकिन सवाल यह है कि क्या चुना जाना चाहिए? यह उपयोग के मामलों पर निर्भर करता है। अपने अनुभव से, मैं इस छद्म संहिता का पालन करता हूं:

 if io_bound: if io_very_slow: print("Use Asyncio") else: print("Use Threads") else: print("Multi Processing")

सीपीयू बाउंड => मल्टी प्रोसेसिंग
आई / ओ बाउंड, फास्ट आई / ओ, कनेक्शन की सीमित संख्या => मल्टी थ्रेडिंग
I / O बाउंड, धीमा I / O, कई कनेक्शन => Asyncio

[नोट। अनुवादक]

मल्टीथ्रेडिंग और जीआईएल पर रूसी में व्याख्यान (प्रस्तुति)।

एसिंक्रोनस पायथन: प्रतियोगिता के विभिन्न रूप

शब्दों की परिभाषा:

सूत्र और प्रक्रियाएँ

Asyncio - क्या, कैसे और क्यों?

सही चुनाव करना।

More articles: