Async/await kwa asyncio inafanya kazi vipi?

Question

IT Interview Practice · Accepted Answer

**asyncio** ni framework ya Python kwa **concurrent I/O** kwa kutumia `async`/`await`. Inaendesha operesheni nyingi za I/O kwa ushirikiano kwenye **thread moja** kupitia event loop — inafaa kwa I/O-bound kazi yenye concurrency ya juu (simu za mtandao, seva za wavuti) bila overhead ya threads.

## Kufafanua na kuendesha 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
```

Funktion ya `async def` ni **coroutine**; `await` inasimamisha kwa nukta ya I/O, na kuruhusu event loop kuendesha *coroutines nyingine* wakati wa kusimama — kisha inaendelea wakati operesheni iliyosubiriwa inapomaliza.

## Faida kuu: 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` inaendesha coroutines **concurrently** — wakati moja inasubiri I/O, nyingine zinaendelea. Subira tatu za sekunde 1 zinaunganishwa kwa ~sekunde 1 jumla. Hii ndio thamani ya asili: kuunganisha waits wengi wa I/O kwenye thread moja.

## Jinsi inafaa kutofautiana na 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)
```

## Kanuni ya kaida: usisimamie 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)
```

Kwa sababu iko ushirikiano na single-threaded, simu yoyote inayoziba/CPU-kubwa inasimamisha *coroutines zote*. Tumia `await`-able async APIs, na hamisha kazi ya kuziba/CPU kwa executor.

## Ambapo asyncio inaangaza

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

## Kwa nini inamaanisha

asyncio ni njia ya kuendelea kwa **high-concurrency I/O** katika Python, ikipanga frameworks kama FastAPI na kuwezesha kuhandle kuhusu wamilioni wa sambamba kwenye thread moja — nyingi zaidi kuliko thread-kwa-kuunganisha.

Kufahamu coroutines, `await`, utekelezaji wa ushirikiano kwa `gather`, na hasa **kanuni ya kaida** (usisimamie event loop; hamisha kazi ya CPU/kuziba) ni muhimu kwa kuandika async Python inayofanya kazi vizuri.

Kujua wakati inafaa (I/O-bound concurrency) dhidi ya wakati haifai (CPU-bound → multiprocessing) ndio ufunguo wa kumtumibu kwa ufanisi.

Kufafanua na kuendesha coroutines

Faida kuu: concurrent I/O

Jinsi inafaa kutofautiana na threads

Kanuni ya kaida: usisimamie event loop

Ambapo asyncio inaangaza

Kwa nini inamaanisha

Maswali yanayohusiana