Lección 35 de 47 · Concurrencia: hilos, procesos y async✦ WebMCP implementado
async/await: corrutinas, gather y TaskGroup
10 min de lectura4 retos
Esta es la lección donde async y await se ponen a trabajar. Verás qué es una corrutina, cómo lanzar varias a la vez con gather y create_task, cómo cancelarlas todas si una falla con TaskGroup, cómo ponerles límite de tiempo y de cantidad, y los dos fallos clásicos: bloquear el bucle con time.sleep y olvidar el await.
¿De dónde vienen los nombres?
gather = inglés gather (reunir, juntar)
Lanza varias corrutinas a la vez y reúne sus resultados en una lista, en el mismo orden en que se las diste.
Convierte una corrutina en una tarea que el bucle empieza a atender sin que tengas que esperarla ya. Es dar el pedido a la cocina y quedarte con el resguardo.
TaskGroup = inglés task group (grupo de tareas)
Un grupo que espera a todas sus tareas al salir del bloque, y las cancela si una falla. Llegó en Python 3.11.
Semaphore = griego sema (señal) + phoros (portador); en informática, el semáforo de tren
Un contador de «plazas»: deja pasar a un máximo de N a la vez y el resto espera. Lo inventó Edsger Dijkstra, por las señales de los trenes.
timeout = inglés time out (tiempo fuera)
Pone un límite: si el bloque tarda más, se cancela y salta TimeoutError.
En 4 ideas
1/4
async def crea una corrutina: al llamarla no se ejecuta, devuelve un objeto que alguien debe esperar con await o lanzar con asyncio.run. En PHP, llamar a una función ya la ejecuta.
asyncio.gather(a, b, c) las ejecuta a la vez y devuelve los resultados en orden de argumento; create_task empieza una ya y la esperas luego; TaskGroup las cancela todas si una falla (en Amp de PHP es async() + await()).
Se les puede poner límite: asyncio.timeout(seg) para el tiempo y asyncio.Semaphore(n) para cuántas a la vez.
Dos fallos clásicos: time.sleep dentro de una corrutina congela el bucle entero (usa asyncio.sleep), y olvidar el await deja una corrutina sin ejecutar (RuntimeWarning: coroutine ... was never awaited).
1 · Una corrutina no se ejecuta al llamarla
En PHP, carga(3) ejecuta la función en ese mismo momento. En Python, si carga es async def, llamarla no ejecuta nada: te devuelve una corrutina, como una receta escrita. Alguien tiene que ponerse a cocinarla: await (dentro de otra corrutina) o asyncio.run (desde fuera).
carga_tarea(1) crea la corrutina; todavía no ha ocurrido nada.
await corrutina la ejecuta y da el valor que devuelve (el return).
asyncio.run(main()) crea el bucle de eventos, ejecuta main hasta el final y lo cierra. Se llama una sola vez, al principio de tu programa.
Solo se puede escribir awaitdentro de una async def. Fuera es un error de sintaxis.
2 · Varias a la vez: gather y create_task
Esperar con await una detrás de otra no gana nada: es lo mismo que hacerlo en orden. Lo que da ventaja es lanzar varias antes de esperar. La herramienta más usada es asyncio.gather:
Fíjate en la diferencia entre cuándo llegan (B, C, A, según lo que tarda cada una) y cómo te las devuelvegather: en el orden en que las pusiste (A, B, C). Así puedes emparejar resultados con peticiones sin pensar.
Las dos imprimen A,B: el resultado respeta el orden de la lista, no el de llegada.
En PHP esto necesita la biblioteca Amp (amphp/amp, que usa Fibers por debajo): async() lanza la tarea y Amp\Future\await() espera a todas.
En Python viene de serie: asyncio.gather y asyncio.sleep (el delay() de Amp).
gather espera a todas a la vez. A veces quieres empezar una y seguir con otra cosa. Eso es create_task: la tarea queda programada y la recoges más tarde con await.
Pythonmain.py
import asyncio
asyncdefdescarga(titulo, espera):
print(f"empieza {titulo}")
await asyncio.sleep(espera)
print(f"termina {titulo}")
return titulo
asyncdefmain():
tarea = asyncio.create_task(descarga("A", 0.03))
print("la tarea está creada")
print("hago otra cosa mientras")
resultado = await tarea
print("recogida:", resultado)
asyncio.run(main())
3 · TaskGroup: si una falla, caen todas
¿Qué pasa si una de las tareas lanza un error? Con gather, el error sale a la vista, pero las demás siguen corriendo por su cuenta, a veces sin que nadie las espere. TaskGroup (Python 3.11) lo arregla: es un with que espera a todas al salir y, si una falla, cancela las demás.
Pythonmain.py
import asyncio
asyncdeflarga():
try:
await asyncio.sleep(1)
print("esto no se llega a imprimir")
except asyncio.CancelledError:
print("larga: cancelada")
raiseasyncdeffalla():
await asyncio.sleep(0.01)
raiseValueError("tarea sin título")
asyncdefmain():
try:
asyncwith asyncio.TaskGroup() as grupo:
grupo.create_task(larga())
grupo.create_task(falla())
except* ValueErroras errores:
print("errores:", [str(e) for e in errores.exceptions])
asyncio.run(main())
falla lanza un ValueError a los 0,01 s. El grupo cancela a larga, que lo avisa con CancelledError.
Al salir del async with, los errores llegan empaquetados en un grupo de excepciones (ExceptionGroup), porque varias tareas podrían fallar a la vez.
Para atraparlos se usa except* (con asterisco, de Python 3.11): «atrapa los ValueError que haya dentro del grupo».
#
Situación
asyncio.gather
asyncio.TaskGroup
1
Si una tarea falla
Te llega el primer error; las demás siguen
Se cancelan las demás
2
Cuántos errores ves
Solo el primero (por defecto)
Todos, en un ExceptionGroup
3
Cuándo usarlo
Pedir varias cosas independientes y recoger una lista
Un trabajo en el que todo tiene que salir bien o no vale
¿Por qué? · En PHP no existe
¿Por qué un grupo que cancela? En PHP no existe
Es lo que se llama concurrencia estructurada: ninguna tarea puede quedar suelta, viva sin que nadie la espere, cuando el bloque que la creó ya terminó. Evita el fallo de lanzar trabajo y olvidarlo, que acaba escribiendo en una base de datos cuando ya nadie lo necesita.
En PHP clásico no hace falta pensar en ello: al terminar la petición, todo muere. Un programa Python que sigue vivo, en cambio, tiene que limpiar lo que lanza.
4 · Poner límites: tiempo y cantidad
Esperar a la red es esperar a algo que puede no llegar nunca. Por eso se pone un límite de tiempo con asyncio.timeout. Si el bloque tarda más, se cancela y salta TimeoutError:
El otro límite es de cantidad. Si lanzas 1000 peticiones a la vez, el servidor del otro lado se hunde (o te bloquea). Un semáforo deja pasar a un máximo de N: el resto espera su turno en la puerta. Este programa lanza 5 tareas con un semáforo de 2 y mide cuántas estuvieron dentro a la vez:
Pythonmain.py
import asyncio
activas = 0
maxima = 0asyncdeftrabaja(id, semaforo):
global activas, maxima
asyncwith semaforo:
activas += 1
maxima = max(maxima, activas)
await asyncio.sleep(0.01)
activas -= 1asyncdefmain():
semaforo = asyncio.Semaphore(2)
await asyncio.gather(*(trabaja(i, semaforo) for i inrange(5)))
print("máximo a la vez:", maxima)
asyncio.run(main())
5 · El fallo número uno: bloquear el bucle
Todo asyncio descansa en una promesa: cada corrutina devuelve el turno cuando espera. Si una no lo devuelve, el cocinero se queda plantado delante de su olla y las demás ollas se queman. El culpable típico es time.sleep, que bloquea todo el programa y no deja al bucle atender a nadie:
Pythonmain.pySolo lectura: bloquea el bucle (no lo ejecutes en la lección)
$ python main.py
empieza A
termina A
empieza B
termina B
Aunque se lanzaron con gather, van una detrás de otra: A ni empieza a esperar a otros, porque time.sleep congela el bucle. Cambia una palabra (asyncio.sleep con await) y las dos corren a la vez:
¿Por qué time.sleep rompe asyncio? En PHP no existe
time.sleep le dice al sistema: «duerme todo este programa». Como asyncio corre en un solo hilo, el bucle de eventos también duerme, y nadie puede reanudar a B. asyncio.sleep, en cambio, dice: «reanúdame dentro de 0,05 s y mientras, atiende a otros».
En PHP-FPM no ocurre porque cada petición tiene su propio proceso: que uno duerma no frena a los demás. Aquí todas las conexiones comparten un solo cocinero: lo que bloquea uno, lo sufren todos.
Lo mismo vale para cualquier cosa que espere sin await: una petición con requests, un open().read() enorme, un cálculo de segundos. Se resuelve con bibliotecas async (httpx, aiohttp) o mandando lo bloqueante a un hilo.
Esa última salida existe en la biblioteca estándar: asyncio.to_thread ejecuta una función normal (bloqueante) en un hilo y te deja esperarla con await sin congelar el bucle:
Pythonmain.pySolo lectura: necesita hilos del sistema
import asyncio
import time
deflee_fichero_lento(nombre):
time.sleep(0.02)
returnf"contenido de {nombre}"asyncdefmain():
textos = await asyncio.gather(
asyncio.to_thread(lee_fichero_lento, "a.txt"),
asyncio.to_thread(lee_fichero_lento, "b.txt"),
)
print(textos)
asyncio.run(main())
$ python main.py
['contenido de a.txt', 'contenido de b.txt']
6 · El fallo número dos: olvidar el await
Como llamar a una async def no la ejecuta, olvidar el await no da error en ese momento: simplemente la corrutina nunca corre. Python solo se chiva al final, con un aviso en rojo:
$ python main.py
main.py:10: RuntimeWarning: coroutine 'guarda_tarea' was never awaited
guarda_tarea("Comprar pan")
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
fin
Mira: el programa termina sin error, imprime fin y la tarea no se guardó nunca. Si además intentas usar el resultado, el error es otro, más raro:
TypeError: 'coroutine' object is not subscriptable
RuntimeWarning: coroutine 'carga_tarea' was never awaited
7 · La pregunta del programador web
La pregunta que te vas a hacer
Vale, pero… ¿cómo hago una petición HTTP o una consulta a la base de datos con async?
Con una biblioteca hecha para async: no sirve la de siempre, porque bloquearía el bucle. Para HTTP son habituales httpx (cliente con versión async) y aiohttp; FastAPI está pensado para este modelo y lo verás en el módulo 09. Para bases de datos hay driversasync por motor, y SQLite viene con sqlite3 síncrono (se usa en un hilo).
Ahora main espera solo la primera carga y imprime ['A']. Usa asyncio.gather para lanzar las dos a la vez (cargar("A", 0.03) y cargar("B", 0.01)) e imprime la lista de resultados, que debe ser ['A', 'B']: el orden de los argumentos, no el de llegada.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.gather devuelve una lista con los resultados: resultados = await asyncio.gather(cargar("A", 0.03), cargar("B", 0.01)).
Reto 2 de 4 · ✓ Resuelto
Cargar todas las tareas
Ya tienes la corrutina cargar_tarea(id). Escribe cargar_todas(ids): lanza todas a la vez con asyncio.gather y devuelve la lista de tareas en el mismo orden que ids. await cargar_todas([3, 1]) da [{"id": 3, ...}, {"id": 1, ...}]. Si ids está vacío, devuelve []. Sería el equivalente a lanzar varias consultas a la base de datos a la vez.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.asyncio.gather(*(cargar_tarea(id) for id in ids)) y conviértelo con list(...). El * reparte los elementos como argumentos.
Reto 3 de 4 · ✓ Resuelto
Un semáforo para no saturar
procesa(ids, limite) lanza una tarea por cada id, pero ahora todas a la vez. Añade un asyncio.Semaphore(limite) para que como mucho limite estén dentro a la vez. Devuelve el máximo de tareas simultáneas que hubo. await procesa([1, 2, 3, 4, 5], 2) da 2; con limite 10 y 5 ids da 5.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Crea semaforo = asyncio.Semaphore(limite) fuera de una y envuelve el cuerpo de una con async with semaforo:.
Reto 4 de 4 · ✓ Resuelto
Con plazo
Escribe con_plazo(corrutina, segundos): espera la corrutina, pero si tarda más de segundos, devuelve None en vez de esperar. Si llega a tiempo, devuelve su resultado. Usa asyncio.timeout y atrapa TimeoutError. Es el curl con CURLOPT_TIMEOUT de PHP, pero para cualquier espera.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.try: con async with asyncio.timeout(segundos): return await corrutina y except TimeoutError: return None.
Resumen
Lo que te llevas de esta lección
async def crea una corrutina que no corre al llamarla; await la ejecuta; asyncio.run(main()) arranca el bucle una vez (en PHP, llamar a una función la ejecuta).
asyncio.gather(a, b) las lanza a la vez y devuelve los resultados en orden de argumento; create_task programa una y la recoges luego (en PHP, Amp: async() y await()).
TaskGroup cancela todas si una falla y junta los errores en un ExceptionGroup (se atrapa con except*).
asyncio.timeout(seg) limita el tiempo y asyncio.Semaphore(n) limita cuántas van a la vez.
Nunca time.sleep dentro de una corrutina: congela el bucle entero. Usa await asyncio.sleep o asyncio.to_thread para lo bloqueante.
Un await olvidado no da error: la corrutina nunca corre y solo avisa was never awaited.
Para recordarlo: «Siempre Await, Nunca Sleep bloqueante»
RRun asyncio.run(main()) una sola vez
AAwait cada corrutina se espera, o no corre
GGather varias a la vez, resultados en orden
SSleep asyncio.sleep, nunca time.sleep
RAGS: Run, Await, Gather, Sleep. Y si falta el await, el cocinero ni siquiera mira esa olla.