पाइथॉन एसिन्सियो कम्प्लीट गाइड: 2026 में कॉन्करेंसी में महारत हासिल करना

वास्तव में क्या asyncio हल करता है

asyncio एक काम के लिए मौजूद है: थ्रेड या प्रक्रियाओं के ओवरहेड के बिना, एक ही थ्रेड पर कई I/O-बाउंड ऑपरेशन को एक साथ चलाना। जब आपका प्रोग्राम अपना अधिकांश समय प्रतीक्षा में बिताता है – डेटाबेस प्रतिक्रिया, HTTP उत्तर, फ़ाइल पढ़ने के लिए – asyncio उसे निष्क्रिय बैठने के बजाय उस प्रतीक्षा के दौरान अन्य कार्य पर स्विच करने देता है।

यह सीपीयू-बाध्य समानता से मौलिक रूप से अलग है। asyncio आपको अधिक CPU कोर नहीं देता है; यह आपको I/O पर प्रतीक्षा करते समय सिंगल कोर का बेहतर उपयोग प्रदान करता है। सीपीयू-भारी काम (इमेज प्रोसेसिंग, नंबर क्रंचिंग) के लिए, आप अभी भीmultiprocessingचाहते हैं या एक मूल विस्तार.

इवेंट लूप, समझाया गया

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

import asyncio

async def say_hello():
    print("start")
    await asyncio.sleep(1)
    print("end")

asyncio.run(say_hello())

asyncio.run()एक ताज़ा ईवेंट लूप बनाता है, कोरआउटिन को पूरा होने तक चलाता है, फिर लूप को बंद कर देता है। यह किसी भी एसिंकियो स्क्रिप्ट के लिए सही शीर्ष-स्तरीय प्रवेश बिंदु है – पुरानेget_event_loop().run_until_complete()से बचें पैटर्न, जब तक कि आपके पास लूप को मैन्युअल रूप से प्रबंधित करने का कोई विशिष्ट कारण न हो।

कोरूटाइन बनाम कार्य

एक कोरआउटिन ऑब्जेक्ट (एकasync defफ़ंक्शन को कॉल करके बनाया गया) अपने आप कुछ नहीं करता है – यह एक रुका हुआ जनरेटर जैसा ऑब्जेक्ट है जो संचालित होने की प्रतीक्षा कर रहा है। इसकी प्रतीक्षा में यह क्रमिक रूप से इनलाइन चलता है। एकार्यएक कोरआउटिन लपेटता है और इसे तुरंत इवेंट लूप पर समवर्ती रूप से चलाने के लिए शेड्यूल करता है।

import asyncio
import time

async def fetch(n):
    await asyncio.sleep(1)
    return n * 2

async def sequential():
    start = time.perf_counter()
    results = [await fetch(i) for i in range(5)]
    print("sequential:", time.perf_counter() - start)
    return results

async def concurrent():
    start = time.perf_counter()
    tasks = [asyncio.create_task(fetch(i)) for i in range(5)]
    results = await asyncio.gather(*tasks)
    print("concurrent:", time.perf_counter() - start)
    return results

asyncio.run(sequential())   # ~5 seconds
asyncio.run(concurrent())   # ~1 second

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

इकट्ठा () बनाम टास्कग्रुप

asyncio.gather()पायथन 3.4 के बाद से कई कॉरआउट्स को एक साथ चलाने का मानक तरीका रहा है, लेकिन इसमें एक तेज धार है: यदि एक कार्य बढ़ता है, तो अन्य पृष्ठभूमि में चलते रहते हैं जब तक कि आप पास नहीं हो जातेreturn_exceptions=Trueऔर त्रुटियों को मैन्युअल रूप से संभालें। यह उत्पादन लॉग में अनाथ कार्यों और हैंडल न की गई अपवाद चेतावनियों का एक सामान्य स्रोत है।

पायथन 3.11 प्रस्तुत किया गयाasyncio.TaskGroup, एक संरचित समवर्ती आदिम जो इसे ठीक से ठीक करता है: यदि कोई बच्चा कार्य विफल हो जाता है, तो समूह शेष सभी सहोदर कार्यों को रद्द कर देता है और एकExceptionGroupउठाता है। हर असफलता से युक्त.

import asyncio

async def risky(n):
    if n == 2:
        raise ValueError("boom at " + str(n))
    await asyncio.sleep(1)
    return n

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            results = [tg.create_task(risky(i)) for i in range(4)]
    except* ValueError as eg:
        for exc in eg.exceptions:
            print("caught:", exc)

asyncio.run(main())

|||| सिंटैक्स हैंडलexcept*उदाहरण, आपको केवल पहली विफलता के बजाय समूह में हुई प्रत्येक विफलता को संसाधित करने देता है। यदि आप Python 3.11 या बाद के संस्करण को लक्षित कर रहे हैं, तोExceptionGroupको प्राथमिकता दें अधिक कच्चाTaskGroupतुच्छ आग और भूल समवर्ती से परे किसी भी चीज़ के लिए।gather()Async संदर्भ प्रबंधक और ताले

समवर्ती कार्यों में साझा परिवर्तनशील स्थिति को अभी भी सुरक्षा की आवश्यकता है, यहां तक ​​कि एक ही थ्रेड पर भी, क्योंकि

पॉइंट ऑपरेशन के बीच में किसी अन्य कार्य को नियंत्रण सौंप सकता है।awaitमहत्वपूर्ण अनुभागों की उसी प्रकार सुरक्षा करता हैasyncio.Lockधागों के लिए करता है.threading.LockLock_example.py

import asyncio

counter = 0
lock = asyncio.Lock()

async def increment():
    global counter
    async with lock:
        current = counter
        await asyncio.sleep(0)  # simulate a yield point
        counter = current + 1

async def main():
    await asyncio.gather(*(increment() for _ in range(100)))
    print(counter)  # always 100, never less

asyncio.run(main())

उपज बिंदु पढ़ने और लिखने के बीच एक और कार्य छोड़ देगाawait asyncio.sleep(0), जिसके कारण अद्यतन खो गए – क्लासिक दौड़ की स्थिति, कई के बजाय केवल एक थ्रेड पर।counterब्लॉकिंग कॉल ट्रैप

यह “मेरा एसिंकियो ऐप धीमा है” बग रिपोर्ट का सबसे बड़ा स्रोत है। इवेंट लूप सिंगल-थ्रेडेड है। कोई भी सिंक्रोनस कॉल जो ब्लॉक करती है –

, एक अवरोधनtime.sleep(), एक सीपीयू-भारी लूप, धीमी डिस्क पर पढ़ी जाने वाली एक अनबफ़र्ड फ़ाइल – पूरे लूप को फ़्रीज़ कर देती है, जिसमें उस पर प्रतीक्षा कर रहे हर दूसरे कार्य भी शामिल हैं।requests.get()Bad_vs_good.py

# BAD: blocks the whole event loop for 2 seconds
import time
async def bad():
    time.sleep(2)

# GOOD: yields control back to the loop
import asyncio
async def good():
    await asyncio.sleep(2)

# GOOD: offload a real blocking call to a thread
async def good_blocking_lib():
    result = await asyncio.to_thread(some_blocking_function, arg1, arg2)
    return result

का उपयोग करें एकasyncio.to_thread()के साथ इसके बजाय – जीआईएल के कारण थ्रेड्स सीपीयू-बाउंड कार्य में मदद नहीं करेंगे।loop.run_in_executor()समयबाह्य और रद्दीकरणProcessPoolExecutorउत्पादन कोड को प्रत्येक बाहरी कॉल पर टाइमआउट की आवश्यकता होती है। पायथन 3.11 जोड़ा गया

Timeouts and Cancellation

Production code needs timeouts on every external call. Python 3.11 addedasyncio.timeout()पुरानेasyncio.wait_for()के लिए एक स्वच्छ संदर्भ-प्रबंधक प्रतिस्थापन के रूप में .

import asyncio

async def slow_call():
    await asyncio.sleep(10)

async def main():
    try:
        async with asyncio.timeout(2):
            await slow_call()
    except TimeoutError:
        print("operation timed out after 2s")

asyncio.run(main())

जब टाइमआउट सक्रिय होता है, तो एसिंसियोasyncio.CancelledErrorबढ़ाकर आंतरिक कार्य को रद्द कर देता है इसके अंदर. यदि आपका कोरआउटिन उन संसाधनों को लपेटता है जिन्हें सफाई (खुले कनेक्शन, फ़ाइल हैंडल) की आवश्यकता होती है, तोtry/finallyका उपयोग करें या एक एसिंक संदर्भ प्रबंधक ताकि रद्दीकरण से संसाधनों का रिसाव न हो।

वास्तविक उदाहरण: समवर्ती एपीआई फ़ेचर

Here’s a complete, production-shaped example: fetching multiple URLs concurrently with a connection limit, a per-request timeout, and structured error handling usingaiohttp.

import asyncio
import aiohttp

async def fetch_one(session, url, semaphore):
    async with semaphore:
        try:
            async with asyncio.timeout(5):
                async with session.get(url) as resp:
                    return url, resp.status, await resp.text()
        except (TimeoutError, aiohttp.ClientError) as e:
            return url, None, str(e)

async def fetch_all(urls, max_concurrent=10):
    semaphore = asyncio.Semaphore(max_concurrent)
    async with aiohttp.ClientSession() as session:
        async with asyncio.TaskGroup() as tg:
            tasks = [tg.create_task(fetch_one(session, u, semaphore)) for u in urls]
        return [t.result() for t in tasks]

urls = ["https://example.com"] * 50
results = asyncio.run(fetch_all(urls))
print(len(results), "requests completed")

|||| caps how many requests run at once, which protects both your client and the target server from being overwhelmed by hundreds of simultaneous connections. This pattern — session reuse, semaphore-bounded concurrency, per-request timeout, structured task group — is close to what you’d see in a production scraper or API aggregator.Semaphoreसामान्य गलतियाँ

कोरआउटिन की प्रतीक्षा करना भूल जाना।

• एकको कॉल कर रहा हूँasync defके बिना कार्य करें बस एक कोरटाइन ऑब्जेक्ट बनाता है और कुछ नहीं करता है – पायथन चेतावनी देगा “कोरटाइन का कभी इंतजार नहीं किया गया था” लेकिन शोर वाले लॉग में इसे मिस करना आसान है।awaitबिना सन्दर्भ रखे कार्य बनाना।
• केवल आंतरिक रूप से एक कमजोर संदर्भ रखता है; यदि कार्य ऑब्जेक्ट पूरा होने से पहले कचरा एकत्र कर लेता है, तो इसे चुपचाप रद्द किया जा सकता है। कार्यों को एक सूची या सेट में तब तक संग्रहीत करें जब तक वे पूरे न हो जाएं। asyncio.create_task()सिंक और एसिंक डेटाबेस ड्राइवरों को मिलाना।
• Using a blocking driver (like plain) inside async code defeats the purpose — use an async driver (psycopg2,asyncpg) or wrap the call withaiomysql.to_thread()टाइमआउट सेट नहीं किया जा रहा.
• बिना टाइमआउट के एक सिंगल हैंग नेटवर्क कॉल पूरे अनुरोध हैंडलर को लोड के तहत अनिश्चित काल तक रोक सकता है।CPU-बाउंड कार्य के लिए asyncio का अत्यधिक उपयोग करना।
• यदि आपकी बाधा गणना है, प्रतीक्षा नहीं, तो एसिंकियो गति जोड़े बिना जटिलता जोड़ता है।अक्सर पूछे जाने वाले प्रश्न