asyncio este framework-ul Python pentru I/O concurent folosind async/await. Execută multiple operații de I/O în mod cooperativ pe o singură thread prin intermediul unui event loop — eficient pentru lucrul I/O-bound cu concurență ridicată (apeluri de rețea, servere web) fără overhead-ul thread-urilor.
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
O funcție async def este o corutină; await o suspendă într-un punct de I/O, permițând event loop-ului să ruleze alte corutine în timp ce asta se întâmplă — apoi se reia când operația așteptată se completează.
# ❌ 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 execută corutine concurent — în timp ce una așteaptă I/O, celelalte continuă. Trei așteptări de 1 secundă se suprapun în ~1 secundă total. Aceasta este valoarea principală: suprapunerea multor așteptări de I/O pe o singură 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)
Pentru că este cooperativ și single-threaded, orice apel blocker/CPU-intensiv blochează toate corutinele. Folosește API-uri async cu await, și delegă lucrul blocker/CPU la un 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 este abordarea modernă pentru I/O de concurență ridicată în Python, alimentând framework-uri ca FastAPI și permițând gestionarea eficientă a miilor de conexiuni simultane pe o singură thread — mult mai ușor decât thread-per-conexiune.
Înțelegerea corutinelor, await, execuției concurente cu gather, și în special a regulii cardinale (nu bloca niciodată event loop-ul; delegă lucrul CPU/blocker) este esențială pentru scrierea Python-ului asincron performant.
Știind când funcționează (I/O-bound concurrency) în comparație cu când nu funcționează (CPU-bound → multiprocessing) este cheia pentru a-l folosi eficient.