async/await र asyncio कसरी काम गरे?

Question

Accepted Answer

**asyncio** Python को **concurrent I/O** को लागि framework हो जसले `async`/`await` प्रयोग गरे। यो एक event loop मार्फत **single thread** मा धेरै I/O operations सहकार्यात्मकरूपमा चलाए — यो high-concurrency I/O-bound कामको लागि थ्रेडको ओभरहेडबिना कुशल हुन्छ (network calls, web servers)।

## Coroutines परिभाषित र चलाउने

```python
import asyncio

async def fetch_data(id):       # an async function = a coroutine
    print(f"start {id}")
    await asyncio.sleep(1)       # await a non-blocking I/O operation (yields control)
    print(f"done {id}")
    return id

asyncio.run(fetch_data(1))       # run a coroutine from sync code
```

एक `async def` function एक **coroutine** हु न्छ; `await` यसलाई एक I/O बिन्दुमा suspend गरे, जसले event loop लाई अन्य coroutines चलाउन दिए — र फेरि awaited operation पूरा हुँदा resume हुन्छ।

## मुख्य लाभ: concurrent I/O

```python
# ❌ sequential — total time ≈ 3 seconds
async def slow():
    await fetch_data(1)   # wait 1s
    await fetch_data(2)   # then wait 1s
    await fetch_data(3)   # then wait 1s

# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
    await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
```

`asyncio.gather` coroutines लाई **concurrently** चलाए — एकजना I/O को लागि await गरेको बेलामा, अन्यहरु अगाडि बढ्छन्। तीन 1-second waits ~1 second कुल समयमा ओभरल्याप हुन्छन्। यो मुख्य मूल्य हो: एक thread मा धेरै I/O waits लाई ओभरल्याप गर्ने।

## यो कसरी threads देखि भिन्न छ

```text
Threading:  OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio:    single thread, COOPERATIVE — coroutines yield at `await` points
            → lighter weight (handle thousands of connections), no thread overhead,
              but one CPU-heavy coroutine blocks everything (no preemption)
```

## मुख्य नियम: event loop लाई block नगर्नुहोस्

```python
async def bad():
    time.sleep(5)              # ❌ BLOCKS the whole event loop (sync sleep)
    result = heavy_compute()    # ❌ CPU work freezes all coroutines

async def good():
    await asyncio.sleep(5)      # ✅ non-blocking
    # offload CPU work to a thread/process pool
    await loop.run_in_executor(None, heavy_compute)
```

किनकि यो सहकार्यात्मक र single-threaded हु न्छ, कुनै पनि blocking/CPU-heavy कल सबै coroutines लाई फ्रिज गरे। `await`-able async APIs प्रयोग गर्नुहोस्, र blocking/CPU कामलाई executor मा अलग गर्नुहोस्।

## asyncio कहाँ चमकदार छ

```text
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
  websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
```

## यो किन महत्त्वपूर्ण छ

asyncio Python मा **high-concurrency I/O** को आधुनिक दृष्टिकोण हु न्छ, जसले FastAPI जस्ता frameworks लाई शक्तिशाली गर्छ र एक single thread मा हजारहजार simultaneous connections को कुशल ढंगले सम्भालने सक्षम गर्छ — thread-per-connection भन्दा धेरै हल्का। coroutines, `await`, `gather` संग concurrent execution बुझ्ने, र विशेष गरी **मुख्य नियम** (कहिले पनि event loop लाई block नगर्नुहोस्; CPU/blocking कामलाई अलग गर्नुहोस्) performant async Python लेख्नको लागि आवश्यक हुन्छ। यो कहाँ फिट हुन्छ (I/O-bound concurrency) बनाम कहाँ छैन (CPU-bound → multiprocessing) जान्ने यसलाई प्रभावकारीरूपमा प्रयोग गर्नको लागि महत्त्वपूर्ण छ।