Una corrutina puede pausarse mientras espera una respuesta de red o de una base de datos y dejar que otra tarea avance en ese tiempo. Las palabras clave async y await son la base de este mecanismo en Python.

Parece simple, pero este conjunto de herramientas puede emplearse fácilmente de forma incorrecta. Una función definida con async puede parecer asíncrona, y asyncio.run() efectivamente inicia un bucle de eventos. Ninguno de esos hechos garantiza que el programa realice varias operaciones de forma concurrente.

En esta guía aprenderás qué hace falta para que las tareas cedan el control al bucle de eventos y compartan el tiempo de espera, logrando así concurrencia efectiva en Python.

Una función asíncrona no se ejecuta al llamarla

Definir una función con async y def crea una función corrutina. Llamar a esa función no ejecuta su cuerpo de inmediato. En su lugar, la llamada devuelve un objeto corrutina:

Python REPL
>>> async def fetch_data():
...     return 42
...

>>> coroutine = fetch_data()
>>> coroutine
<coroutine object fetch_data at 0x...>
>>> coroutine.close()

Al llamar a fetch_data(), obtienes un objeto corrutina. El cuerpo de la función todavía no se ejecuta. En este ejemplo, coroutine.close() cierra el objeto sin ejecutarlo para evitar una advertencia al salir del entorno interactivo de Python.

Para ejecutar una corrutina, debes esperarla desde otra función asíncrona con await o pasarla directamente a asyncio.run().

El bucle de eventos asíncrono

La función asyncio.run() es fundamental en la programación asíncrona en Python. Esta función inicia el bucle de eventos y ejecuta la corrutina que se le pasa como argumento desde un contexto síncrono.

Como continuación del ejemplo anterior, puedes pasar la corrutina directamente a asyncio.run() para ejecutarla y obtener el valor que devuelve:

Python REPL
>>> import asyncio

>>> async def fetch_data():
...     return 42
...

>>> asyncio.run(fetch_data())
42

La llamada a asyncio.run() espera a que la corrutina termine y devuelve su resultado. En este caso, el resultado es 42.

El bucle de eventos no es un motor mágico de ejecución paralela. Ejecuta una pieza de código Python a la vez. Cuando el bucle de eventos está ejecutando una corrutina, ninguna otra puede avanzar hasta que la actual se suspenda con await.

El proceso funciona de la siguiente manera:

  1. asyncio.run() pone en marcha el bucle de eventos y ejecuta la corrutina principal.
  2. La corrutina principal llega a un await y espera otra corrutina. Si esta termina enseguida, el programa continúa.
  3. Si la corrutina tiene que esperar, por ejemplo, una respuesta de la red, en ese momento se pausa y el control vuelve al bucle de eventos.
  4. El bucle de eventos recibe el control y puede avanzar otras corrutinas que estén listas para ejecutarse.
  5. Cuando termina la espera de la corrutina pausada, la tarea continúa desde donde se pausó hasta completar su ejecución.

Al terminar la corrutina principal, asyncio.run() devuelve su resultado y cierra el bucle de eventos. Si la corrutina no devuelve un valor, el resultado es None.

La espera secuencial no es concurrencia

Considera dos operaciones llamadas A y B que demoran un segundo en ejecutarse cada una:

Python - sequential_awaits.py
import asyncio
import time

async def fetch(name, delay):
    print(f"{name}: iniciada")
    await asyncio.sleep(delay)
    print(f"{name}: finalizada")
    return f"resultado de {name}"

async def main():
    start = time.perf_counter()
    await fetch("A", 1)
    await fetch("B", 1)
    sequential_time = time.perf_counter() - start
    print(f"Tiempo secuencial: {sequential_time:.1f} segundos")

asyncio.run(main())

La operación B no comienza hasta que la operación A ha terminado. Puedes comprobarlo observando la salida del script y el tiempo total de ejecución con el siguiente comando:

Terminal
$ python sequential_awaits.py
A: iniciada
A: finalizada
B: iniciada
B: finalizada
Tiempo secuencial: 2.0 segundos

Tu programa tarda unos dos segundos en ejecutarse porque espera a que termine la primera operación antes de iniciar la segunda. Aunque fetch() es asíncrona, las dos llamadas se ejecutan secuencialmente, por lo que tu código no es asíncrono sino síncrono.

La llamada await fetch("A", 1) ejecuta la operación, mientras el programa espera a que termine para continuar con la siguiente línea de código, es decir, la llamada a fetch("B", 1). Por sí sola, una espera con await no inicia otras operaciones al mismo tiempo.

Crear tareas realmente concurrentes: el ingrediente que falta

Para que un programa en Python sea realmente concurrente, necesitas crear tareas que puedan ejecutarse de manera independiente, sin depender unas de otras. Estas tareas deben poder ejecutarse, pausarse y reanudarse, es decir, deben ser corrutinas.

Luego, necesitas crear y lanzar estas tareas de manera asíncrona. Esto lo puedes hacer con asyncio.TaskGroup, asyncio.gather() y asyncio.as_completed().

Uso de TaskGroup

La clase TaskGroup es un manejador de contexto que se usa para la ejecución concurrente de un grupo de tareas asíncronas dentro de un bloque async with.

Un grupo de tareas hace dos cosas importantes:

  1. Crea una tarea para cada corrutina que se pasa a group.create_task().
  2. Espera a todas las tareas antes de salir del bloque async with.

Observa un ejemplo de cómo usar TaskGroup:

Python - taskgroup_example.py
import asyncio
import time

async def fetch(name, delay):
    print(f"{name}: iniciada")
    await asyncio.sleep(delay)
    print(f"{name}: finalizada")
    return f"resultado de {name}"

async def main():
    start = time.perf_counter()

    async with asyncio.TaskGroup() as group:
        group.create_task(fetch("A", 1))
        group.create_task(fetch("B", 1))

    elapsed = time.perf_counter() - start
    print(f"Tiempo transcurrido: {elapsed:.1f} segundos")

asyncio.run(main())

En este ejemplo, ambas tareas, A y B, se inician casi al mismo tiempo y se ejecutan de manera concurrente dentro del bloque async with.

Ejecuta el script con el siguiente comando para ver la ejecución concurrente de las tareas:

Terminal
$ python taskgroup_example.py
A: iniciada
B: iniciada
A: finalizada
B: finalizada
Tiempo transcurrido: 1.0 segundos

El tiempo total es de aproximadamente un segundo porque las esperas de ambas tareas se solapan. Las tareas se ejecutan de forma concurrente dentro del grupo, que espera a que ambas finalicen antes de terminar y pasar a la siguiente instrucción del programa.

TaskGroup ofrece un control más estructurado sobre el ciclo de vida de las tareas. Las agrupa y espera a que todas terminen. Si una tarea lanza una excepción distinta de CancelledError, cancela las demás y luego propaga las excepciones como un grupo. Por eso suele ser una buena opción para código nuevo cuando las tareas deben gestionarse como una unidad.

Uso de gather()

Para situaciones donde solo necesitas recolectar resultados de varias corrutinas, gather() es la herramienta ideal:

Python - gather_example.py
import asyncio
import time

async def fetch(name, delay):
    print(f"{name}: iniciada")
    await asyncio.sleep(delay)
    print(f"{name}: finalizada")
    return f"resultado de {name}"

async def main():
    start = time.perf_counter()

    await asyncio.gather(
        fetch("A", 1),
        fetch("B", 1),
    )

    elapsed = time.perf_counter() - start
    print(f"Tiempo transcurrido: {elapsed:.1f} segundos")

asyncio.run(main())

En este ejemplo, asyncio.gather() te permite ejecutar las tareas A y B de manera concurrente y esperar a que ambas finalicen antes de continuar.

Ejecuta el script con este comando:

Terminal
$ python gather_example.py
A: iniciada
B: iniciada
A: finalizada
B: finalizada
Tiempo transcurrido: 1.0 segundos

En la práctica, gather() es conveniente cuando tu objetivo principal es recolectar resultados. La función devuelve los resultados en el mismo orden en que se proporcionaron los objetos que admiten await, aunque las tareas terminen en otro orden.

El patrón esencial es el mismo en TaskGroup y gather(): crear o recibir varias corrutinas, ponerlas en marcha como tareas y luego esperar a que todas terminen.

Uso de as_completed()

Mientras que gather() devuelve los resultados en el orden de entrada, as_completed() los devuelve en el orden en que terminan las tareas. Esto es útil cuando quieres manejar los resultados tan pronto como estén disponibles.

Considera el siguiente ejemplo:

Python - as_completed_example.py
import asyncio

async def fetch(name, delay):
    print(f"{name}: iniciada")
    await asyncio.sleep(delay)
    return f"resultado de {name}"

async def main():
    tasks = [
        asyncio.create_task(fetch("A", 3)),
        asyncio.create_task(fetch("B", 1)),
        asyncio.create_task(fetch("C", 2)),
    ]

    for completed in asyncio.as_completed(tasks):
        result = await completed
        print(result)

asyncio.run(main())

Ejecuta el script con este comando:

Terminal
$ python as_completed_example.py
A: iniciada
B: iniciada
C: iniciada
resultado de B
resultado de C
resultado de A

En este ejemplo, la tarea B termina primero, luego la C y finalmente la A, y sus resultados se procesan en ese mismo orden.

Las llamadas bloqueantes impiden la concurrencia

El código asíncrono también es afectado por el uso de operaciones bloqueantes, que son aquellas que detienen el bucle de eventos hasta que se completan.

Declarar una función síncrona con async def no hace que deje de ser bloqueante. Para eso, también se necesita un await sobre una operación no bloqueante, como una solicitud a un servidor de red o el acceso a una base de datos.

Por ejemplo, time.sleep() bloquea el bucle de eventos por completo pues no puede esperarse con await:

Python - blocking_task.py
import asyncio
import time

async def bad_task(name):
    print(f"{name}: iniciada")
    time.sleep(1)  # Bloquea el bucle de eventos
    print(f"{name}: finalizada")

async def main():
    start = time.perf_counter()
    async with asyncio.TaskGroup() as group:
        group.create_task(bad_task("A"))
        group.create_task(bad_task("B"))
    elapsed = time.perf_counter() - start
    print(f"Tiempo transcurrido: {elapsed:.1f} segundos")

asyncio.run(main())

Ejecuta el script con el siguiente comando:

Terminal
$ python blocking_task.py
A: iniciada
A: finalizada
B: iniciada
B: finalizada
Tiempo transcurrido: 2.0 segundos

Aunque ambas tareas están listas para ejecutarse, la tarea B no puede avanzar mientras la tarea A ejecuta la llamada bloqueante time.sleep(). El bucle de eventos queda atascado esperando a que la llamada retorne, por lo que el programa tarda unos dos segundos en lugar de uno.

Conclusión

La programación asíncrona en Python no consiste en añadir async a cada función ni en envolver un programa en asyncio.run(). Esas características establecen la maquinaria, pero no producen concurrencia de forma automática.

El código asíncrono funciona como se pretende cuando:

  • Varias corrutinas se ponen en marcha como tareas.
  • Las tareas ceden el control al bucle de eventos en puntos await no bloqueantes.
  • El bucle de eventos tiene otro trabajo listo para ejecutar cuando una tarea cede el control.
  • Las operaciones bloqueantes se mantienen fuera del bucle de eventos.

Una vez que estas reglas quedan claras, el comportamiento de asyncio resulta mucho menos misterioso.