async/await asyncio ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

IT Interview Practice · Accepted Answer

**asyncio** `async`/`await` ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ **concurrent I/O** ਲਈ Python ਦਾ ਫ੍ਰੇਮਵਰਕ ਹੈ। ਇਹ event loop ਦੁਆਰਾ **ਇੱਕ ਥ੍ਰੈਡ** ਉੱਤੇ ਬਹੁਤ ਸਾਰੇ I/O ਓਪਰੇਸ਼ਨ ਨੂੰ ਸਹਿ-ਆਪਣੇ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ — ਉੱਚ-ਕਨਕੱਰਵੇਂਸੀ I/O-ਬਾਉਂਡ ਕੰਮ (ਨੈੱਟਵਰਕ ਕਾਲ, ਵੈੱਬ ਸਰਵਰ) ਲਈ ਪ੍ਰਭਾਵੀ ਹੈ ਥ੍ਰੈਡਸ ਦੀ ਓਵਰਹੈੱਡ ਤੋਂ ਬਿਨਾਂ।

## 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` ਫੰਕਸ਼ਨ ਇੱਕ **coroutine** ਹੈ; `await` ਇਸਨੂੰ I/O ਪੁਆਇੰਟ ਉੱਤੇ ਮੁਅੱਤਲ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ event loop *ਦੂਸਰੇ* coroutines ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ — ਫਿਰ ਜਦੋਂ awaited ਓਪਰੇਸ਼ਨ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ ਤਾਂ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦਾ ਹੈ।

## ਮੁੱਖ ਲਾਭ: 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 ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ, ਦੂਸਰੇ ਅੱਗੇ ਵਧਦੇ ਹਨ। ਤਿੰਨ 1-ਸਕਿੰਟ ਦੀ ਉਡੀਕ ~1 ਸਕਿੰਟ ਕੁੱਲ ਵਿੱਚ ਮਿਲ ਜਾਂਦੀ ਹੈ। ਇਹ ਮੂਲ ਮਤਲਬ ਹੈ: ਇੱਕ ਥ੍ਰੈਡ ਉੱਤੇ ਬਹੁਤ ਸਾਰੀ I/O ਉਡੀਕਾਂ ਨੂੰ ਓਵਰਲੈਪ ਕਰਨਾ।

## ਇਹ ਥ੍ਰੈਡਸ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ

```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 ਨੂੰ ਬਲਾਕ ਨਾ ਕਰੋ

```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)
```

ਕਿਉਂਕਿ ਇਹ ਸਹਿ-ਆਪਣੇ ਤਰੀਕੇ ਨਾਲ ਹੈ ਅਤੇ ਸਿੰਗਲ-ਥ੍ਰੈਡਡ ਹੈ, ਕੋਈ ਵੀ ਬਲਾਕਿੰਗ/CPU-ਭਾਰੀ ਕਾਲ *ਸਮੁੱਚੇ* coroutines ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰ ਦਿੰਦਾ ਹੈ। `await`-ਮਾਡੀ async APIs ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਬਲਾਕਿੰਗ/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 ਵਿੱਚ **ਉੱਚ-ਕਨਕੱਰਵੇਂਸੀ I/O** ਦਾ ਆਧੁਨਿਕ ਤਰੀਕਾ ਹੈ, FastAPI ਵਰਗੀ ਫ੍ਰੇਮਵਰਕ ਨੂੰ ਸ਼ਕਤੀ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਥ੍ਰੈਡ ਉੱਤੇ ਹਜ਼ਾਰਾਂ ਸਮਕਾਲੀ ਸਂਪਰਕਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ — ਥ੍ਰੈਡ-ਪ੍ਰਤੀ-ਸੰਪਰਕ ਤੋਂ ਬਹੁਤ ਹਲਕਾ।

Coroutines, `await`, `gather` ਦੇ ਨਾਲ concurrent ਐਕਸੀਕਿਊਸ਼ਨ, ਅਤੇ ਖਾਸ ਤੌਰ ਉੱਤੇ **ਮੁੱਖ ਨਿਯਮ** (event loop ਨੂੰ ਕਦੇ ਬਲਾਕ ਨਾ ਕਰੋ; CPU/ਬਲਾਕਿੰਗ ਕੰਮ ਨੂੰ ਨਿਰਦੇਸ਼ ਕਰੋ) ਨੂੰ ਸਮਝਣਾ ਸਧਾਰਨ async Python ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ ਇਹ ਕਦੋਂ ਫਿੱਟ ਬੈਠਦਾ ਹੈ (I/O-ਬਾਉਂਡ concurrency) ਬਨਾਮ ਜਦੋਂ ਇਹ ਨਹੀਂ ਹੁੰਦਾ (CPU-ਬਾਉਂਡ → multiprocessing) ਇਸ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਵਰਤਣ ਲਈ ਚਾਬੀ ਹੈ।

Coroutines ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਅਤੇ ਚਲਾਉਣਾ

ਮੁੱਖ ਲਾਭ: concurrent I/O

ਇਹ ਥ੍ਰੈਡਸ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ

ਮੁੱਖ ਨਿਯਮ: event loop ਨੂੰ ਬਲਾਕ ਨਾ ਕਰੋ

ਜਿੱਥੇ asyncio ਚਮਕਦਾ ਹੈ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ