asyncio ist Pythons Framework für parallele I/O mit async/await. Es führt viele I/O-Operationen kooperativ auf einem einzigen Thread über eine Event Loop aus – effizient für hochgradig parallele I/O-gebundene Arbeiten (Netzwerkaufrufe, Webserver) ohne den Overhead von 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
Eine async def-Funktion ist eine Coroutine; await setzt sie an einem I/O-Punkt aus und lässt die Event Loop unterdessen andere Coroutines ausführen – dann setzt sie sich fort, wenn die erwartete Operation abgeschlossen ist.
# ❌ 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 führt Coroutines gleichzeitig aus – während eine auf I/O wartet, fahren die anderen fort. Drei Wartezeiten von je 1 Sekunde überlappen sich zu insgesamt ~1 Sekunde. Das ist der Kernwert: Überlappung vieler I/O-Wartezeiten auf einem 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)
Da es kooperativ und single-threaded ist, friert jeder blockierende/CPU-intensive Aufruf alle Coroutines ein. Verwende await-fähige Async-APIs und lagere blockierende/CPU-Arbeit an einen Executor aus.
✓ 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 ist der moderne Ansatz für hochgradig parallele I/O in Python und treibt Frameworks wie FastAPI an, wodurch die effiziente Verarbeitung von Tausenden gleichzeitiger Verbindungen auf einem einzigen Thread möglich ist – weitaus leichter als Thread-pro-Verbindung.
Das Verständnis von Coroutines, await, gleichzeitiger Ausführung mit gather und besonders der Kardinalregel (blockiere die Event Loop niemals; lagere CPU-/blockierende Arbeit aus) ist essentiell für das Schreiben von performantem asynchronem Python.
Zu wissen, wann es passt (I/O-gebundene Parallelität) und wann nicht (CPU-gebunden → Multiprocessing) ist der Schlüssel, um es effektiv einzusetzen.