Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 35 de 47 · Concurrencia: hilos, procesos y async ✦ WebMCP implementado

async/await: corrutinas, gather y TaskGroup

10 min de lectura 4 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.
create_task = inglés create (crear) + task (tarea)
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.

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).

Pythonmain.py
import asyncio


async def carga_tarea(id):
    await asyncio.sleep(0.01)
    return {"id": id, "titulo": f"Tarea {id}"}


async def main():
    corrutina = carga_tarea(1)
    print(type(corrutina).__name__)

    tarea = await corrutina
    print(tarea["titulo"])


asyncio.run(main())
  1. carga_tarea(1) crea la corrutina; todavía no ha ocurrido nada.
  2. await corrutina la ejecuta y da el valor que devuelve (el return).
  3. 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.
  4. Solo se puede escribir await dentro 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:

Pythonmain.py
import asyncio


async def carga(titulo, espera):
    await asyncio.sleep(espera)
    print(f"llegó {titulo}")
    return titulo


async def main():
    resultados = await asyncio.gather(
        carga("A", 0.05),
        carga("B", 0.01),
        carga("C", 0.03),
    )
    print(resultados)


asyncio.run(main())

Fíjate en la diferencia entre cuándo llegan (B, C, A, según lo que tarda cada una) y cómo te las devuelve gather: en el orden en que las pusiste (A, B, C). Así puedes emparejar resultados con peticiones sin pensar.

PHP 8.5amp.php
<?php
declare(strict_types=1);

use function Amp\async;
use function Amp\delay;
use function Amp\Future\await;

$futuros = [
    async(function (): string {
        delay(0.05);
        return "A";
    }),
    async(function (): string {
        delay(0.01);
        return "B";
    }),
];

$resultados = await($futuros);
echo implode(",", $resultados) . PHP_EOL;
Pythonmain.py
import asyncio


async def tarea(nombre, segundos):
    await asyncio.sleep(segundos)
    return nombre


async def main():
    resultados = await asyncio.gather(tarea("A", 0.05), tarea("B", 0.01))
    print(",".join(resultados))


asyncio.run(main())
  1. Las dos imprimen A,B: el resultado respeta el orden de la lista, no el de llegada.
  2. 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.
  3. 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


async def descarga(titulo, espera):
    print(f"empieza {titulo}")
    await asyncio.sleep(espera)
    print(f"termina {titulo}")
    return titulo


async def main():
    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


async def larga():
    try:
        await asyncio.sleep(1)
        print("esto no se llega a imprimir")
    except asyncio.CancelledError:
        print("larga: cancelada")
        raise


async def falla():
    await asyncio.sleep(0.01)
    raise ValueError("tarea sin título")


async def main():
    try:
        async with asyncio.TaskGroup() as grupo:
            grupo.create_task(larga())
            grupo.create_task(falla())
    except* ValueError as errores:
        print("errores:", [str(e) for e in errores.exceptions])


asyncio.run(main())
  1. falla lanza un ValueError a los 0,01 s. El grupo cancela a larga, que lo avisa con CancelledError.
  2. Al salir del async with, los errores llegan empaquetados en un grupo de excepciones (ExceptionGroup), porque varias tareas podrían fallar a la vez.
  3. Para atraparlos se usa except* (con asterisco, de Python 3.11): «atrapa los ValueError que haya dentro del grupo».
#Situaciónasyncio.gatherasyncio.TaskGroup
1Si una tarea fallaTe llega el primer error; las demás siguenSe cancelan las demás
2Cuántos errores vesSolo el primero (por defecto)Todos, en un ExceptionGroup
3Cuándo usarloPedir varias cosas independientes y recoger una listaUn 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:

Pythonmain.py
import asyncio


async def lenta():
    await asyncio.sleep(1)
    return "llegó tarde"


async def main():
    try:
        async with asyncio.timeout(0.05):
            print(await lenta())
    except TimeoutError:
        print("se acabó el tiempo")


asyncio.run(main())

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 = 0


async def trabaja(id, semaforo):
    global activas, maxima
    async with semaforo:
        activas += 1
        maxima = max(maxima, activas)
        await asyncio.sleep(0.01)
        activas -= 1


async def main():
    semaforo = asyncio.Semaphore(2)
    await asyncio.gather(*(trabaja(i, semaforo) for i in range(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)
import asyncio
import time


async def descarga(titulo, segundos):
    print(f"empieza {titulo}")
    time.sleep(segundos)
    print(f"termina {titulo}")


async def main():
    await asyncio.gather(descarga("A", 0.05), descarga("B", 0.01))


asyncio.run(main())
$ 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:

Pythonmain.py
import asyncio


async def descarga(titulo, segundos):
    print(f"empieza {titulo}")
    await asyncio.sleep(segundos)
    print(f"termina {titulo}")


async def main():
    await asyncio.gather(descarga("A", 0.05), descarga("B", 0.01))


asyncio.run(main())

¿Por qué? · En PHP no existe

¿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


def lee_fichero_lento(nombre):
    time.sleep(0.02)
    return f"contenido de {nombre}"


async def main():
    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:

Pythonmain.py
import asyncio


async def guarda_tarea(titulo):
    await asyncio.sleep(0.01)
    print(f"guardada: {titulo}")


async def main():
    guarda_tarea("Comprar pan")
    print("fin")


asyncio.run(main())
$ 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:

Pythonmain.py
async def main():
    tarea = carga_tarea(1)
    print(tarea["titulo"])
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 drivers async por motor, y SQLite viene con sqlite3 síncrono (se usa en un hilo).

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Dos a la vez con gather

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

Resumen

Lo que te llevas de esta lección

  1. 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).
  2. 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()).
  3. TaskGroup cancela todas si una falla y junta los errores en un ExceptionGroup (se atrapa con except*).
  4. asyncio.timeout(seg) limita el tiempo y asyncio.Semaphore(n) limita cuántas van a la vez.
  5. Nunca time.sleep dentro de una corrutina: congela el bucle entero. Usa await asyncio.sleep o asyncio.to_thread para lo bloqueante.
  6. 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.