asyncio é o framework de Python para I/O concorrente usando async/await. Executa muitas operações de I/O cooperativamente em uma única thread através de um event loop — eficiente para trabalho I/O-bound de alta concorrência (chamadas de rede, servidores web) sem o overhead de 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
Uma função async def é uma corrotina; await a suspende em um ponto de I/O, permitindo que o event loop execute outras corrotinas enquanto isso — depois retoma quando a operação aguardada se completa.
# ❌ 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 executa corrotinas concorrentemente — enquanto uma aguarda I/O, as outras prosseguem. Três esperas de 1 segundo se sobrepõem em ~1 segundo total. Este é o valor principal: sobrepor muitas esperas de I/O em uma 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)
Porque é cooperativo e single-threaded, qualquer chamada bloqueante/CPU-intensiva congela todas as corrotinas. Use APIs async com await, e delegue trabalho bloqueante/CPU a um 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 é a abordagem moderna para I/O de alta concorrência em Python, alimentando frameworks como FastAPI e permitindo o tratamento eficiente de milhares de conexões simultâneas em uma única thread — muito mais leve do que thread-por-conexão.
Compreender corrotinas, await, execução concorrente com gather, e especialmente a regra cardinal (nunca bloqueie o event loop; delegue trabalho CPU/bloqueante) é essencial para escrever Python assíncrono performático.
Saber quando funciona (I/O-bound concurrency) versus quando não funciona (CPU-bound → multiprocessing) é a chave para usá-lo efetivamente.