Asyncio: una introducción

Definiciones

El módulo asyncio proporciona un marco de trabajo que gira en torno al bucle de eventos. Un bucle de eventos básicamente espera a que ocurra algo y luego reacciona ante ese evento. Se encarga de gestionar, entre otras cosas, la E/S y los eventos del sistema.

De hecho, asyncio dispone de varias implementaciones de bucle. El módulo elige por defecto la más eficiente para el sistema operativo en el que se ejecuta; no obstante, puedes seleccionar explícitamente el bucle de eventos si lo prefieres. Un bucle de eventos viene a decir «cuando ocurra el evento A, reacciona con la función B».

Piensa en un servidor que espera a que alguien solicite un recurso, como una página web. Si el sitio no es muy popular, el servidor estará ocioso mucho tiempo. Pero cuando reciba una petición, tendrá que reaccionar. Esa reacción se conoce como gestión de eventos. Cuando un usuario carga la página, el servidor comprueba y llama a uno o varios gestores de eventos. Una vez que esos gestores terminan, deben devolver el control al bucle de eventos. Para hacer esto en Python, asyncio utiliza corrutinas.

Una corrutina es una función especial que puede ceder el control a quien la invoca sin perder su estado. Es consumidora y una extensión de un generador. Una de sus grandes ventajas frente a los hilos es que consumen muy poca memoria al ejecutarse. Ten en cuenta que, cuando llamas a una función corrutina, no se ejecuta realmente. En su lugar, devuelve un objeto corrutina que puedes pasar al bucle de eventos para que lo ejecute inmediatamente o más adelante.

Otro término con el que probablemente te encontrarás al usar el módulo asyncio es future. Un future es básicamente un objeto que representa el resultado de un trabajo que aún no ha terminado. Tu bucle de eventos puede vigilar objetos future y esperar a que finalicen. Cuando un future termina, pasa a estado done. Asyncio también admite bloqueos y semáforos.

La última pieza que quiero mencionar es la Task. Una Task es un contenedor para una corrutina y una subclase de Future. Incluso puedes planificar una Task usando el bucle de eventos.

async y await

Las palabras clave async y await se añadieron en Python 3.5 para definir corrutinas nativas y diferenciarlas de las corrutinas basadas en generadores. Si quieres una descripción detallada de async y await, consulta la PEP 492.

En Python 3.4, crearías una corrutina así:

Este decorador sigue funcionando en Python 3.5, pero el módulo types recibió una actualización en forma de una función coroutine que ahora te indica si lo que estás usando es una corrutina nativa o no. A partir de Python 3.5, puedes usar async def para definir sintácticamente una función corrutina.

Así que la función anterior quedaría así:

Cuando defines una corrutina de esta forma, no puedes usar yield dentro de la función corrutina. En su lugar, debe incluir una sentencia return o await, que sirven para devolver valores al invocador. Ten presente que la palabra clave await solo puede usarse dentro de una función async def.

Las palabras clave async/await pueden considerarse una API para programar de forma asíncrona. El módulo asyncio es simplemente un framework que casualmente utiliza async/await para la programación asíncrona. De hecho, hay un proyecto llamado curio que demuestra este concepto, ya que es una implementación independiente de un bucle de eventos que usa async/await bajo el capó.

Un mal ejemplo de corrutina

Aunque viene bien tener bastante contexto sobre cómo funciona todo esto, a veces solo quieres ver ejemplos para hacerte una idea de la sintaxis y de cómo encajar las piezas.

Con eso en mente, ¡empecemos con un ejemplo sencillo!

Una tarea bastante común es descargar un archivo de algún sitio, ya sea un recurso interno o un archivo en Internet. Normalmente querrás descargar más de uno.

Así que vamos a crear un par de corrutinas para hacerlo:

import asyncio
import os
import urllib.request
 
async def download_coroutine(url):
    #"A coroutine to download the specified url"
    request = urllib.request.urlopen(url)
    filename = os.path.basename(url)
 
    with open(filename, 'wb') as file_handle:
        while True:
            chunk = request.read(1024)
            if not chunk:
                break
            file_handle.write(chunk)
    msg = 'Finished downloading {filename}'.format(filename=filename)
    return msg
 
async def main(urls):
    """
    Creates a group of coroutines and waits for them to finish
    """
    coroutines = [download_coroutine(url) for url in urls]
    completed, pending = await asyncio.wait(coroutines)
    for item in completed:
        print(item.result())
 
 
if __name__ == '__main__':
    urls = ["http://www.irs.gov/pub/irs-pdf/f1040.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"]
 
    event_loop = asyncio.get_event_loop()
    try:
        event_loop.run_until_complete(main(urls))
    finally:
        event_loop.close()

En este código importamos los módulos necesarios y luego creamos nuestra primera corrutina usando la sintaxis async. Esta corrutina se llama download_coroutine y utiliza urllib de Python para descargar la URL que se le pase. Cuando termina, devuelve un mensaje indicándolo.

La otra corrutina es la principal. Básicamente toma una lista de una o más URLs y las pone en cola. Usamos la función wait de asyncio para esperar a que las corrutinas terminen. Por supuesto, para que las corrutinas empiecen realmente, hay que añadirlas al bucle de eventos. Lo hacemos al final: obtenemos un bucle de eventos y llamamos a su método run_until_complete. Verás que le pasamos la corrutina principal al bucle de eventos. Esto inicia la ejecución de la corrutina principal, que pone en cola la segunda corrutina y la pone en marcha. A esto se le llama corrutina encadenada.

El problema de este ejemplo es que en realidad no es una corrutina como tal. La razón es que la función download_coroutine no es asíncrona. El problema aquí es que urllib no es asíncrona y, además, no estoy usando await ni yield. Una forma mejor de hacerlo sería utilizar el paquete aiohttp. ¡Veámoslo!

Un mejor ejemplo de corrutina

El paquete aiohttp está diseñado para crear clientes y servidores HTTP asíncronos. Puedes instalarlo con pip así:

pip install aiohttp

Una vez instalado, actualicemos el código para usar aiohttp y poder descargar los archivos:

Verás que importamos un par de elementos nuevos: aiohttp y async_timeout. Este último es en realidad una dependencia de aiohttp y nos permite crear un gestor de contexto de tiempo de espera. Empecemos por la parte inferior del código y vayamos hacia arriba. En la condición final, iniciamos el bucle de eventos asíncrono y llamamos a nuestra función principal.

En la función principal, creamos un objeto ClientSession que pasamos a nuestra función corrutina de descarga para cada una de las URLs que queremos descargar. En download_coroutine, creamos un gestor de contexto async_timeout.timeout() que básicamente inicia un temporizador de X segundos. Cuando el tiempo se agota, el gestor de contexto finaliza o expira. En este caso, el tiempo de espera es de 10 segundos. A continuación, llamamos al método get() de la sesión, que nos da un objeto respuesta. Aquí llega la parte un poco mágica. Cuando usas el atributo content del objeto respuesta, devuelve una instancia de aiohttp.StreamReader, que nos permite descargar el archivo por bloques del tamaño que queramos. A medida que leemos el archivo, lo escribimos en disco local. Por último, llamamos al método release() de la respuesta, que finaliza su procesamiento.

Según la documentación de aiohttp, como el objeto respuesta se creó dentro de un gestor de contexto, técnicamente se llama a release() de forma implícita. Pero en Python, lo explícito suele ser mejor, y la documentación indica que no deberíamos confiar en que la conexión se cierre sin más, así que creo que en este caso es mejor liberarla explícitamente.

Hay una parte que sigue bloqueando: la escritura en disco. Mientras escribimos el archivo, seguimos bloqueando. Existe otra biblioteca, aiofiles, que podríamos usar para intentar que la escritura sea también asíncrona, pero dejo esa mejora a quien lea esto.

Planificación de llamadas

También puedes planificar llamadas a funciones normales usando el bucle de eventos de asyncio. El primer método que veremos es call_soon. Este método llamará a tu callback o gestor de eventos en cuanto pueda. Funciona como una cola FIFO, así que si algunas devoluciones de llamada tardan en ejecutarse, las siguientes se retrasarán hasta que las anteriores finalicen.

Veamos un ejemplo:

La mayoría de las funciones de asyncio no aceptan palabras clave, así que necesitaremos el módulo functools si queremos pasarlas a nuestro gestor de eventos. Nuestra función normal imprimirá texto por stdout cada vez que se llame. Si estableces su argumento stop en True, también detendrá el bucle de eventos.

La primera vez que la llamamos no detenemos el bucle. La segunda vez, sí. Queremos detenerlo porque le hemos indicado que haga run_forever, lo que pone el bucle en un ciclo infinito. Una vez detenido, podemos cerrarlo.

Si ejecutas este código, verás una salida como esta:

starting event loop
Event handler called
Event handler called
stopping the loop
closing event loop

Existe una función relacionada llamada call_soon_threadsafe. Como su nombre indica, funciona igual que call_soon, pero es segura para hilos. Si quieres retrasar una llamada hasta algún momento futuro, puedes usar la función call_later. En este caso, podríamos cambiar la firma de call_soon por la siguiente:

loop.call_later(1, event_handler, loop)

Esto retrasará la llamada a nuestro gestor de eventos un segundo; después lo llamará y le pasará el bucle como primer parámetro. Si quieres planificar un momento concreto en el futuro, tendrás que obtener el tiempo del propio bucle en lugar del tiempo del sistema. Puedes hacerlo así:

current_time = loop.time()

Con eso, basta con usar la función call_at y pasarle el instante en el que quieres que se llame a tu gestor de eventos. Por ejemplo, si queremos llamarlo dentro de cinco minutos, podríamos hacerlo así:

loop.call_at(current_time + 300, event_handler, loop)

En este ejemplo usamos el tiempo actual que hemos obtenido y le sumamos 300 segundos (cinco minutos). De esta forma, ¡retrasamos la llamada a nuestro gestor de eventos cinco minutos! ¡Nada mal!

Tareas

Las tareas (Tasks) son una subclase de Future y un contenedor alrededor de una corrutina. Te permiten llevar un seguimiento de cuándo terminan de procesarse. Como son un tipo de Future, otras corrutinas pueden esperar a una tarea y también puedes obtener el resultado de una tarea cuando haya finalizado.

Veamos un ejemplo sencillo:

Aquí creamos una función asíncrona que recibe el número de segundos que tardará en ejecutarse, lo que simula un proceso de larga duración. Luego creamos el bucle de eventos y un objeto tarea llamando a la función create_task del bucle. create_task acepta la función que queremos convertir en tarea. Después indicamos al bucle que se ejecute hasta que la tarea termine. Al final, obtenemos el resultado de la tarea, ya que habrá finalizado.

Las tareas también pueden cancelarse fácilmente con su método cancel. Cuando quieras terminar una tarea, llámalo. Si una tarea se cancela mientras está esperando otra operación, lanzará una CancelledError.

Para terminar

A estas alturas deberías saber lo suficiente como para empezar a trabajar por tu cuenta con la biblioteca asyncio. Es muy potente y te permite hacer un montón de tareas interesantes. La biblioteca asyncio se diseñó para sockets de red.

Una gran biblioteca que permitía programación asíncrona con sockets antes de asyncio es el framework Twisted. Otro proyecto interesante es Dask, una biblioteca flexible de computación paralela para análisis. Investiga la documentación del módulo asyncio y deja que fluyan las ideas.