Saltearse al contenido

asyncio

asyncio hace con un hilo lo que los hilos hacen con veinte: esperar muchas cosas a la vez. La diferencia no es de rendimiento bruto, es de escala: diez mil conexiones simultáneas con diez mil hilos reservan unos 29 GB de pila en Windows x64; con corrutinas, unos pocos megabytes.

El bucle de eventos espera por ti: cuando una tarea se suspende en await, otra ocupa el hilo.

200 esperas de 5 ms
Modelo Tiempo Aceleración
Serie 1.07 s 1.00×
20 hilos 0.06 s 18.7×
asyncio 0.02 s 48.3×

python mediciones/06-01-08-concurrencia.py

asyncio llega más cerca del límite teórico: 200 esperas de 5 ms son 1 s en serie, y concurrentes bastan unos 5 ms más el bucle (0,02 s medidos), porque no paga el cambio de contexto del sistema operativo.

Y el coste de crear trabajo es mucho menor:

Crear 10 000 unidades de trabajo
Modelo Tiempo
10 000 tareas asyncio 43.4 ms
10 000 tareas en un pool de 10 hilos 74.1 ms

python mediciones/06-01-08-concurrencia.py

Esa es la ventaja real: la tarea de asyncio es un objeto en una lista, no un hilo del sistema.

import asyncio
async def descargar(url):
async with sesion.get(url) as r:
return await r.text()
async def main():
resultados = await asyncio.gather(*(descargar(u) for u in urls))
return resultados
asyncio.run(main())

Tres piezas:

  • async def define una corrutina: llamarla no la ejecuta, devuelve un objeto.
  • await suspende la corrutina y devuelve el control al bucle, que ejecuta otra.
  • asyncio.run crea el bucle, ejecuta y lo cierra.

La palabra clave es suspender: entre dos await, la corrutina no cede el control. Un bucle de cálculo de 100 ms dentro de una corrutina bloquea el bucle entero.

  • Miles de conexiones simultáneas (servidores, clientes de API, scrapers).
  • E/S de red con bibliotecas asíncronas (httpx, asyncpg, aiofiles).
  • Servicios web con frameworks ASGI (FastAPI, Starlette).
  • Cuando el coste de los hilos (memoria, cambio de contexto) es el límite.
  • Si las bibliotecas de tu dominio son síncronas. Envolver todo en run_in_executor es un pool de hilos con más pasos.
  • Si el trabajo es de CPU. Un bucle de eventos con cálculo dentro es un solo núcleo al 100 %.
  • En scripts simples. asyncio.run para tres descargas es más código que un ThreadPoolExecutor.
  • Si el equipo no lo conoce. Un async mal usado es peor que un hilo bien usado: los fallos son silenciosos.

Un servicio debe consultar 50 APIs distintas por petición, cada una con 100 ms de latencia. Escribe el esqueleto con asyncio y explica qué pasa si una de las APIs tarda 10 segundos.

Solución
import asyncio
APIS = [f"api-{i:02d}" for i in range(50)]
LENTA = "api-07" # la que tarda 10 s en la historia; aquí, 1 s
class Cliente:
"""Cliente de mentira: cada API tarda 0.1 s y la lenta, 1 s."""
async def get(self, api):
await asyncio.sleep(1.0 if api == LENTA else 0.1)
return {"api": api, "ok": True}
async def consultar(cliente, api, timeout):
async with asyncio.timeout(timeout):
return await cliente.get(api)
async def agregar(cliente, apis, timeout):
tareas = [consultar(cliente, api, timeout) for api in apis]
return await asyncio.gather(*tareas, return_exceptions=True)
async def manejador():
return await agregar(Cliente(), APIS, timeout=0.5)
resultados = asyncio.run(manejador())
fallos = [r for r in resultados if isinstance(r, Exception)]
buenos = [r for r in resultados if not isinstance(r, Exception)]
print(f"respuestas correctas: {len(buenos)}")
print(f"fallos: {len(fallos)} -> {type(fallos[0]).__name__}")
assert len(buenos) == 49 and len(fallos) == 1, "una API lenta no debe tumbar a las otras 49"

Tiempo esperado: ~100 ms más el overhead, en lugar de 5 segundos en serie. Las 50 peticiones van en vuelo a la vez.

Si una API tarda 10 segundos y no hay timeout, toda la petición espera 10 segundos aunque las otras 49 hayan terminado: gather espera a todas. Con timeout=2.0 en el cliente, esa API falla y las demás devuelven su resultado; con return_exceptions=True, el fallo llega como valor en lugar de cancelar el resto.

El capítulo 05 trata los timeouts, la cancelación y el control de concurrencia con más detalle.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 21: Asynchronous Programming.
  • CPython 3.13: Lib/asyncio/base_events.py, Lib/asyncio/tasks.py.
  • Mediciones: mediciones/06-01-08-concurrencia.py.
  • 05 · asyncio en producción: timeouts, cancelación y TaskGroup.
  • 02 · Hilos: el modelo al que sustituye cuando hay miles de esperas.
  • 08 · Elegir modelo: la tabla que decide entre los tres.