Ir al contenido
wannacode

async no es un hilo

En resumen: asyncio ejecuta corrutinas en un hilo con un bucle de eventos: await suelta el hilo mientras espera, así que una carrera entre dos esperas es posible incluso sin hilos.

Problema

La última unidad, vendida dos veces

Las rebajas van a todo gas. Queda un par de auriculares. checkout comprueba las existencias, espera a que el banco confirme el pago y solo entonces reduce las existencias. Dos clientes pulsan «Comprar» en el mismo momento:

# El banco confirma el pago en 100 ms.
async def pay(buyer):
    await asyncio.sleep(0.1)




class Shop:
    def __init__(self):
        self.stock = 1
        self.sold = 0


    async def checkout(self, buyer):
        left = self.stock
        if left == 0:
            return
        await pay(buyer)
        self.stock = left - 1
        self.sold += 1




async def main():
    shop = Shop()
    await asyncio.gather(shop.checkout("Ana"), shop.checkout("Beto"))
    print(f"Vendidos: {shop.sold}, existencias: {shop.stock}")




asyncio.run(main())
Salida
Vendidos: 2, existencias: 0

Se venden dos, y hay una unidad. Un cliente recibirá un correo «Tu pedido ha sido enviado» por unos auriculares que no existen.

En asyncio esto parece imposible: el código se ejecuta en un hilo. En la lección Condición de carrera dos hilos chocaron en count += 1. Aquí no hay un segundo hilo.

La salida es la misma en cada ejecución: no es mala suerte, es el orden en que se ejecuta el código. Para verlo, hay que saber qué hace await.

La idea

Un hilo y muchas esperas

La mayor parte del trabajo en una tienda en línea es trabajo que espera (mira trabajo que espera y trabajo que calcula): el pago espera al banco, el correo espera al servidor de correo, las existencias esperan al almacén. Un hilo que se queda sentado esperando es un hilo desperdiciado.

Un bucle de eventos es un hilo y una cola de trozos de código que están listos. El hilo toma el siguiente trozo y lo ejecuta hasta el final. Cuando el código llega a una espera, no retiene el hilo: dice «despiértame cuando responda el banco» y lo suelta. El hilo toma el siguiente trozo listo. Cuando el banco responde, el resto de la función (la continuación) entra en la cola y espera su turno.

En Python el bucle de eventos está en asyncio. async def crea una corrutina: una función que puede detenerse a mitad. await es el lugar donde se detiene y suelta el hilo. asyncio.run(main()) inicia el bucle de eventos y, dentro, la corrutina main.

Tres peticiones a tres servicios, lanzadas a la vez:

class Calls:
    def __init__(self):
        self.waiting = 0
        self.most = 0


    async def call(self, name, ms):
        self.waiting += 1
        self.most = max(self.most, self.waiting)
        await asyncio.sleep(ms / 1000)
        self.waiting -= 1
        print(f"{name}: listo tras {ms} ms")




async def main():
    calls = Calls()
    await asyncio.gather(
        calls.call("pago", 300),
        calls.call("correo", 100),
        calls.call("almacén", 200),
    )
    print(f"Esperaron a la vez: {calls.most}")




asyncio.run(main())
Salida
correo: listo tras 100 ms
almacén: listo tras 200 ms
pago: listo tras 300 ms
Esperaron a la vez: 3
asyncio.gather inicia las tres corrutinas y espera a todas. Cada una se ejecuta hasta await asyncio.sleep(...) y suelta el hilo, así que las tres entran en call antes de que ninguna termine.

«Esperaron a la vez: 3»: las tres peticiones esperan al mismo tiempo, y solo hay un hilo. Todo tarda unos 300 ms (la más larga), no 600 (la suma). El hilo no esperó a ninguna de ellas.

Pruébalo

Cuántas esperan a la vez

El mismo call, pero la primera petición se espera sola:

¿Qué imprimirá el programa?

async def main():
    calls = Calls()
    await calls.call("pago", 300)
    await asyncio.gather(calls.call("correo", 100), calls.call("almacén", 200))
    print(f"Esperaron a la vez: {calls.most}")




asyncio.run(main())
Respuesta

Míralo

Una carrera entre dos awaits

Volvamos a la última unidad. Así se entrelazan los dos pedidos:

class Shop:
    def __init__(self):
        self.stock = 1
        self.sold = 0


    async def checkout(self, buyer):
        left = self.stock
        if left == 0:
            return
        await pay(buyer)
        self.stock = left - 1
        self.sold += 1
Paso a paso, en palabras
  1. Queda una unidad. Dos pedidos llegan en el mismo momento: el de Ana y el de Beto.
  2. El checkout de Ana lee las existencias: left es 1. En el await suelta el hilo hasta que responda el banco.
  3. El hilo está libre, así que se ejecuta el checkout de Beto. También lee 1: Ana todavía no ha escrito nada.
  4. El banco responde a Ana. Su código continúa después de await: stock = left - 1 = 0, sold = 1. Hasta aquí es correcto.
  5. Beto continúa con el left = 1 antiguo: otra vez stock = 0, sold = 2. Una unidad, dos ventas, y con un solo hilo.

Entre dos await el código se ejecuta sin interrupción. Pero en un await la función suelta el hilo, y mientras tanto puede ejecutarse cualquier otra cosa. Cuando continúa, el mundo puede ser distinto: left es un valor leído antes de la espera.

Es el mismo «leer, cambiar, escribir» que con hilos, solo que la interrupción no es en cualquier parte, sino exactamente en el await. Por eso la salida es la misma en cada ejecución: la interrupción no es aleatoria.

La idea

La solución: reservar la unidad antes del await

La comprobación y la reducción deben ser un solo trozo de código sin ningún await en medio. El pedido reserva la unidad de inmediato y solo después espera al banco:

class Shop:
    def __init__(self):
        self.stock = 1
        self.sold = 0


    async def checkout(self, buyer):
        if self.stock == 0:
            return
        self.stock -= 1  # reserva la unidad antes del await
        await pay(buyer)
        self.sold += 1
Salida
Vendidos: 1, existencias: 0
No hay ningún await entre if self.stock == 0 y self.stock -= 1, así que ninguna otra corrutina puede colarse en medio. Beto ve 0 y se va.

Si el pago falla, hay que devolver la unidad. Ese es el ejercicio del final.

Más precisamente, para curiosos

A veces hay que bloquear todo el trozo junto con la espera: por ejemplo, solo un pedido a la vez puede escribir en un sistema de almacén antiguo que no soporta dos. Entonces necesitas un cerrojo que entienda await:

asyncio.Lock(): async with lock: suelta el hilo mientras espera el cerrojo. threading.Lock no sirve aquí: bloquea todo el hilo, y con él el bucle de eventos.

Cómo es en los otros lenguajes: en JavaScript y en asyncio hay un hilo, y el trozo entre dos await se ejecuta solo. En C# las continuaciones están en el grupo de hilos, así que allí también hace falta un lock. Java no tiene await: allí se hace lo mismo con CompletableFuture, y desde Java 21 también con hilos virtuales, donde escribes código bloqueante normal y la JVM desmonta el hilo por sí sola mientras espera.

Pruébalo

Encuentra el error

El carrito suma los precios de tres pedidos. El precio viene del almacén con await. Los tres pedidos cuestan 25 € cada uno, y el total sale como 25:

class Cart:
    def __init__(self):
        self.total = 0


    async def add_order(self, order_id):
        self.total += await price_of(order_id)




async def main():
    cart = Cart()
    await asyncio.gather(cart.add_order(1), cart.add_order(2), cart.add_order(3))
    print(f"Total: {cart.total} €")




asyncio.run(main())
Salida
Total: 25 €

Elige la línea con el error.

La idea

No bloquees el bucle de eventos

El bucle de eventos solo funciona si ningún trozo de código retiene el hilo durante mucho tiempo. El informe de ventas se hace con time.sleep(0.3): duerme sin await. A la vez, un cliente abre la página de un producto, que espera 50 ms al almacén:

async def report():
    time.sleep(0.3)  # bloquea: espera 300 ms sin await
    print("El informe está listo")




async def product_page(buyer, start):
    await asyncio.sleep(0.05)
    print(f"{buyer} espera más de 0,25 s: {time.monotonic() - start > 0.25}")




async def main():
    start = time.monotonic()
    await asyncio.gather(report(), product_page("Ana", start))




asyncio.run(main())
Salida
El informe está listo
Ana espera más de 0,25 s: True

La página esperó más de 0,25 s en lugar de 50 ms. Mientras el informe retiene el hilo, ninguna otra continuación puede ejecutarse: ni esta página, ni los pagos, ni los temporizadores. En un servidor con miles de clientes, todos se congelan a la vez.

La solución es sacar el trabajo pesado del hilo del bucle de eventos. Va a un grupo de hilos, y el bucle de eventos solo espera el resultado:

def build_report():
    time.sleep(0.3)




async def report():
    await asyncio.to_thread(build_report)
    print("El informe está listo")




async def product_page(buyer):
    await asyncio.sleep(0.05)
    print(f"{buyer}: la página está lista")




async def main():
    await asyncio.gather(report(), product_page("Ana"))




asyncio.run(main())
Salida
Ana: la página está lista
El informe está listo
await asyncio.to_thread(build_report) ejecuta la función en un grupo de hilos y espera el resultado sin retener el bucle de eventos. Si el trabajo calcula (en vez de dormir), por el GIL necesitas un grupo de procesos: await asyncio.get_running_loop().run_in_executor(processes, build_report), donde processes es un ProcessPoolExecutor.

Pruébalo

Completa

Lanza las tres peticiones a la vez y espéralas juntas:

async def main():
    calls = Calls()
    await (
        calls.call("pago", 300),
        calls.call("correo", 100),
        calls.call("almacén", 200),
    )
    print(f"Esperaron a la vez: {calls.most}")


asyncio.run(main())

Ejercicio

Reservar, cobrar, devolver

Resuélvelo en tu propio editor.

Quedan dos unidades. Cuatro clientes piden a la vez: Ana, Beto, Vera y Gala. El pago tarda 100 ms. La tarjeta de Beto es rechazada: el pago lanza una excepción con el texto «tarjeta rechazada».

checkout reserva la unidad antes del await, luego cobra. Si el pago falla, la unidad se devuelve. Imprime el resultado de cada cliente en el orden de los pedidos, y al final las existencias y el número de vendidos:

Salida
Ana: pagado
Beto: tarjeta rechazada, la unidad se devuelve
Vera: sin existencias
Gala: sin existencias
Existencias: 1, vendidos: 1

Vera y Gala ven «sin existencias», porque la unidad de Beto sigue reservada hasta que responde el banco. Es justo: la unidad devuelta va al siguiente cliente.

Más tareas

  • Intentar de nuevo. Si un cliente no encuentra existencias pero otro podría devolver una unidad, déjalo esperar hasta 200 ms y volver a intentarlo.
  • Timeout. El banco a veces no responde. Si el pago tarda más de 1 s, rechaza el pedido y devuelve la unidad. (asyncio.wait_for)
  • Informe. Calcula el total de las ventas (25 € cada una) e imprímelo al final.

Test

Ponte a prueba

1. ¿En cuántos hilos se ejecuta tu código en JavaScript (Node) y en Python asyncio?
2. Tres peticiones esperan 100, 200 y 300 ms. ¿Cuánto tarda todo si las esperas una por una con await, y cuánto con Promise.all, gather, Task.WhenAll o allOf?
3. En JavaScript y Python una función async lee datos compartidos, espera con await y luego escribe. ¿Cuándo puede otro código cambiar los datos?
4. Atender una petición incluye un cálculo que dura 2 segundos, sin un solo await. ¿Qué pasa con las demás peticiones en Node o asyncio?
5. ¿Cómo evitas vender dos veces la última unidad?

Creado por Ivo Gergov como parte de la campaña de Evo Tech por una educación accesible en programación ·