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.
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.
# ❌ 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.
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)
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.
✓ 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 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.