asyncio is Python's framework voor concurrent I/O met behulp van async/await. Het voert veel I/O-operaties coöperatief uit op een enkele thread via een event loop — efficiënt voor high-concurrency I/O-bound werk (netwerkoproepen, webservers) zonder de overhead van 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
Een async def functie is een coroutine; await onderbreekt deze op een I/O-punt, waardoor de event loop ondertussen andere coroutines kan uitvoeren — en hervat deze wanneer de gewachte bewerking is voltooid.
# ❌ 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 voert coroutines gelijktijdig uit — terwijl de ene op I/O wacht, gaan de andere verder. Drie wachttijden van 1 seconde overlappen tot ongeveer 1 seconde totaal. Dit is de kernwaarde: veel I/O-wachttijden overlappen op één thread.
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)
Omdat het coöperatief en single-threaded is, bevriezen alle blokkerings-/CPU-zware aanroepen alle coroutines. Gebruik await-able async API's en schuif blokkerings-/CPU-werk naar een 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 is de moderne benadering van high-concurrency I/O in Python, die frameworks zoals FastAPI aandrijft en het efficiënt afhandelen van duizenden gelijktijdige verbindingen op een enkele thread mogelijk maakt — veel lichter dan thread-per-verbinding.
Het begrijpen van coroutines, await, gelijktijdige uitvoering met gather, en vooral de kardinale regel (blokkeer de event loop nooit; schuif CPU-/blokkeerwerk uit) is essentieel voor het schrijven van performante async Python.
Weten wanneer het past (I/O-bound concurrency) versus wanneer niet (CPU-bound → multiprocessing) is cruciaal voor effectief gebruik.