asyncio är Pythons ramverk för concurrent I/O med async/await. Det kör många I/O-operationer kooperativt på en enstaka tråd via en event loop — effektivt för högt concurrency I/O-bundet arbete (nätverkssamtal, webbservrar) utan trådars overhead.
asyncio är Pythons ramverk för concurrent I/O med async/await. Det kör många I/O-operationer kooperativt på en enstaka tråd via en event loop — effektivt för högt concurrency I/O-bundet arbete (nätverkssamtal, webbservrar) utan trådars overhead.
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
En async def-funktion är en coroutine; await pausar den vid en I/O-punkt, låtande event loopen köra andra coroutines medans — sedan återupptas när den avvaktade operationen slutförs.
# ❌ 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 kör coroutines concurrently — medan en avvaktar I/O, fortsätter de andra. Tre 1-sekundsväntan överlappar till ~1 sekund totalt. Det här är kärnvärdet: överlappar många I/O-väntningar på en tråd.
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)
Eftersom det är kooperativt och single-threaded, frysas alla coroutines av någon blocking/CPU-tung anrop. Använd await-bara async API:er, och flytta blocking/CPU-arbete till en 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 är den moderna metoden för högconcurrency I/O i Python, driver ramverk som FastAPI och möjliggör effektiv hantering av tusentals samtidiga anslutningar på en enstaka tråd — långt lättare än tråd-per-anslutning.
Att förstå coroutines, await, concurrent exekvering med gather, och särskilt huvudregeln (blockera aldrig event loopen; flytta CPU/blocking-arbete) är essentiellt för att skriva performant async Python.
Att veta när det passar (I/O-bundet concurrency) mot när det inte gör det (CPU-bundet → multiprocessing) är nyckeln till att använda det effektivt.