La noche de la crítica: todo junto

Viernes, diez de la noche. Tal como prometió, entra la clienta de la ventana. Siempre sola, siempre un bol de fideos, siempre el reloj de pulsera y la libretita. Pero hoy, nada más sentarse, deja una tarjeta de visita sobre la mesa. Crítica gastronómica.

«Llevo unas semanas observando esta cocina. Hoy voy a pedir como es debido: el menú de doce platos». La crítica abre su libreta y se quita el reloj de la muñeca.

La cocina se queda en silencio. A Minho se le cae el cuchillo, Sua vuelve a ordenar el riel de comandas y el señor Tak, sin más, limpia los fogones. Lou entra con la comanda. La chef Yoon Seoyeon pone a cero el temporizador que lleva al cuello. «Una cocina es un programa. Hoy ejecutamos todo lo que hemos construido».

12-1. Qué herramienta sacar (8 min)

En once noches hemos acumulado muchas herramientas. Cuando entra un cliente, la primera pregunta es solo una: ¿esto es trabajo de espera o trabajo de manos?

El orden para elegir es este.

1. ¿De verdad hace falta concurrencia? Si hacerlo en orden ya es bastante rápido, déjalo así. Como vimos en la lección 1, la concurrencia no sale gratis.
2. ¿Es espera o es cálculo? Si es espera, asyncio o hilos; si es cálculo, procesos (o 3.14t). En una compilación con GIL, repartir el cálculo entre hilos no lo acelera (lección 8).
3. ¿La biblioteca que ya usas soporta async? Si la soporta, asyncio; si no, empieza con hilos o envuélvela con to_thread dentro de asyncio.
4. ¿Qué se comparte? Si hay estado compartido, añade un cerrojo o una cola; si los recursos tienen un límite, un semáforo; si las cosas deben terminar juntas, un TaskGroup.

12-2. El procesador del menú de la crítica (14 min)

La comanda de la crítica es esta: doce platos, 0,5 segundos por plato. Pero los platos 3, 7 y 11, la primera vez, tardan el triple (1,5 segundos) porque los ingredientes aún no se han descongelado del todo. Al repetirlos, salen en 0,5 segundos. Y solo hay tres fogones.

Hacen falta tres piezas: un semáforo que respete el número de fogones, un límite de tiempo para que ningún plato se eternice y reintentos para repetir los platos que se cortan. Todo dentro de un solo TaskGroup.

import asyncio, time

SLOW = {3, 7, 11}                      # platos que la primera vez tardan el triple

async def plate(n, attempt):
    await asyncio.sleep(0.5 * (3 if n in SLOW and attempt == 0 else 1))

async def order(n, stoves, limit_s, retries):
    for attempt in range(retries + 1):
        async with stoves:             # solo se cocina mientras se tiene un fogón
            try:
                async with asyncio.timeout(limit_s):
                    await plate(n, attempt)
                return True
            except TimeoutError:
                pass                   # suelta el fogón, vuelve al final de la cola y reintenta
    return False

async def service(stoves_n, limit_s, retries):
    stoves = asyncio.Semaphore(stoves_n)
    start = time.perf_counter()
    async with asyncio.TaskGroup() as tg:
        tasks = [tg.create_task(order(n, stoves, limit_s, retries)) for n in range(1, 13)]
    served = sum(t.result() for t in tasks)
    print(f"stoves={stoves_n} limit={limit_s} retries={retries}: "
          f"served {served}/12, {time.perf_counter() - start:.1f}s")

asyncio.run(service(3, None, 0))       # sin límite de tiempo
asyncio.run(service(3, 0.6, 0))        # solo límite
asyncio.run(service(3, 0.6, 1))        # límite + un reintento
# stoves=3 limit=None retries=0: served 12/12, 3.5s
# stoves=3 limit=0.6 retries=0: served 9/12, 2.2s
# stoves=3 limit=0.6 retries=1: served 12/12, 2.7s
# (el tiempo varía unos 0.1 s entre ejecuciones; la primera línea da 3.5s o 3.6s)

• asyncio.timeout(None) significa sin límite. Por eso la misma función sirve para ejecutar «sin límite» y «límite de 0,6 segundos».
• Sin límite, los tres platos lentos ocupan un fogón 1,5 segundos cada uno, y servir los doce lleva algo más de 3,5 segundos.
• Con solo el límite, los platos lentos se cortan a los 0,6 segundos y los fogones quedan libres antes. A cambio, esos tres platos no salen nunca.
• Con límite y reintentos, el plato cortado suelta el fogón y vuelve a ponerse al final de la cola. La segunda vez termina en 0,5 segundos, y salen los doce platos.

Hay dos detalles de diseño que conviene señalar.

• Al reintentar, se suelta el fogón. Como async with stoves está dentro del for, el plato cortado libera el fogón y vuelve a hacer cola. Si reintentara con el fogón en la mano, otros platos se quedarían parados mientras tanto.
• El fallo no se lanza como excepción, sino que se devuelve False. Si salta una excepción en un TaskGroup, se cancela todo lo demás (lección 10). En una reserva de grupo eso es lo correcto, pero en un menú, aunque falle un plato, el resto tiene que salir. Por la misma razón, también podrías reunirlos con asyncio.gather.

En la práctica, es habitual descansar entre reintentos un poco más cada vez, por ejemplo con await asyncio.sleep(0.05 * 2 ** attempt). Así se evita que todos vuelvan a lanzarse a la vez (la misma razón que el bloqueo activo de la lección 5).

La línea de tiempo de abajo ejecuta este mismo procesador en el servidor. Cada fila es un plato; los intentos cortados por el límite de tiempo salen en gris y los reintentos llevan r1, r2. La configuración inicial está hecha a propósito para no cumplir el objetivo.

• Con la configuración inicial (2 fogones, límite de 0,4 segundos, 0 reintentos), a los 2,4 segundos más o menos sale Servidos 0 · Fallidos 12. Incluso un plato normal tarda 0,5 segundos y el límite es de 0,4, así que se cortan todos.
• Si subes a 3 fogones y solo pones 2 reintentos, va peor. Con el mismo límite de 0,4 segundos, cada plato se corta tres veces: siguen sin servirse platos y el tiempo sube a unos 4,9 segundos. Los reintentos no arreglan un límite de tiempo mal elegido. Incluso con el límite igual a un plato normal, 0,5 segundos, se cortan por los pelos y fallan todos.
• Si quitas el límite de tiempo, se sirve todo, pero incluso con 3 fogones tarda algo más de 3,5 segundos. Con 4 fogones baja a unos 3,0 segundos, demasiado justo, y sobre todo: solo hay tres fogones.
• La pantalla solo espera al experimento algo más de 5 segundos. Las configuraciones que tardan mucho, como 2 fogones con 2 reintentos, pueden parecer cortadas a mitad; cambia la configuración y vuelve a ejecutarlo.

12-3. Todo en una cocina (8 min)

El menú de la crítica lleva masa (cálculo), pan del horno viejo (bloqueante) y platos de fogón (espera), todo junto. Cada cosa se le encarga a quien corresponde, y Lou, en la sala, espera a todos. Como usa procesos, guárdalo en un archivo y ejecútalo.

import asyncio, threading, time
from concurrent.futures import ProcessPoolExecutor

def knead(n):                          # masa: trabajo de manos → cocina sucursal (proceso)
    return sum(i * i for i in range(n)) % 97

tally_lock = threading.Lock()          # el libro de cuentas que modifican el hilo del horno y el bucle
tally = {"plates": 0}

def count_plate():
    with tally_lock:                   # dentro del cerrojo no hay await ni trabajo largo
        tally["plates"] += 1

def old_oven(item):                    # horno viejo: bloqueante → hilo
    time.sleep(0.4)
    count_plate()
    return f"{item} baked"

async def stove_dish(n, stoves):       # plato de fogón: semáforo
    async with stoves:
        await asyncio.sleep(0.2)
    count_plate()
    return f"#{n}"

async def main():
    loop = asyncio.get_running_loop()
    stoves = asyncio.Semaphore(3)
    with ProcessPoolExecutor(max_workers=2) as dough_room:
        async with asyncio.timeout(5):         # hora límite de todo el menú
            results = await asyncio.gather(
                loop.run_in_executor(dough_room, knead, 3_000_000),
                asyncio.to_thread(old_oven, "bread"),
                *(stove_dish(n, stoves) for n in range(1, 7)),
            )
    print(results)
    print(tally)

if __name__ == "__main__":
    asyncio.run(main())
# [56, 'bread baked', '#1', '#2', '#3', '#4', '#5', '#6']
# {'plates': 7}

Al libro de cuentas lo modifican tanto el hilo del horno como el bucle, por eso usamos threading.Lock. Que el bucle tome este cerrojo no es un problema, porque dentro no hay ningún await: cambia un número y lo suelta enseguida. El accidente de la lección 11 ocurre cuando se cede el paso con await sin soltar el cerrojo.

12-4. Lista de comprobación de bugs de concurrencia (6 min)

Para que la cocina no se pare delante de la crítica, se revisan estas seis cosas antes del servicio.

El remedio para las «tareas sin referencia» es este: meter las tareas en un conjunto para sujetarlas y que, al terminar, se saquen solas.

import asyncio

running = set()                        # aquí se sujetan las tareas

async def wipe(table):
    await asyncio.sleep(0.05)
    print("wiped", table)

async def main():
    for t in ("T1", "T2"):
        task = asyncio.create_task(wipe(t))
        running.add(task)
        task.add_done_callback(running.discard)   # al terminar, se saca sola
    await asyncio.sleep(0.1)
    print(len(running))

asyncio.run(main())
# wiped T1
# wiped T2
# 0

Una «cola que no termina» aparece en cuanto se olvida un solo task_done(). Si sospechas, ponle un límite de tiempo a join() para comprobarlo.

import asyncio

async def cook(q):
    while True:
        await q.get()
        await asyncio.sleep(0.01)
        # q.task_done()  ← se nos olvidó

async def main():
    q = asyncio.Queue()
    for n in range(3):
        q.put_nowait(n)
    worker = asyncio.create_task(cook(q))
    try:
        async with asyncio.timeout(0.3):
            await q.join()
    except TimeoutError:
        print("join never finished:", q.qsize(), "in queue")
    worker.cancel()

asyncio.run(main())
# join never finished: 0 in queue

La cola está vacía (0 in queue), pero join() no termina. Las tres comandas que se sacaron nunca recibieron la marca de «hecho».

12-5. Volver a poner en marcha las cocinas de once noches (4 min)

Hemos reunido en un solo banco de pruebas las cocinas de las noches anteriores. Ejecuta los mismos ocho pedidos cambiando solo el modo. Los controles de cocineros y fogones solo tienen efecto en los modos que usan esos valores.

• Solo, uno por uno: una sola fila, unos 2,4 segundos (lección 1).
• 4 cocineros: cuatro filas solapadas, unos 0,6 segundos (lección 2). Si limitas los fogones a 2, aparece la espera amarilla y tarda unos 1,2 segundos (lección 4).
• Cocineros de agencia: cuanto más alto el número, más corto el pedido, así que el orden de llegada sale revuelto; unos 0,4 segundos (lección 7).
• gather: las ocho mesas se solapan todas, unos 0,3 segundos (lección 9). Da igual cuántos cocineros haya: Lou sola.

Cierre (10 min)

La configuración que cumple con el menú de la crítica es 3 fogones, límite de 0,6 segundos, 1 reintento. Son valores comprobados ejecutándolos directamente con el motor del banco de pruebas en el servidor.

# con la función service de 12-2
asyncio.run(service(3, 0.6, 1))
# stoves=3 limit=0.6 retries=1: served 12/12, 2.7s

• El límite de 0,6 segundos deja pasar los platos normales (0,5 segundos) y solo corta, a los 0,6, los que se alargan la primera vez (1,5 segundos).
• Los tres platos cortados sueltan el fogón, lo intentan una vez más desde el final de la cola y terminan en 0,5 segundos.
• Si bajas un poco el límite, a 0,55 segundos, también se cumple el objetivo (unos 2,65 segundos). Si lo subes a 0,7, tarda unos 2,9 segundos, pegado a los 3; con 0,8, se pasa de 3 segundos.

Sale el duodécimo plato: 2,7 segundos. El temporizador de la chef se detiene. La crítica escribe unas líneas en su libreta, termina su bol de fideos y se levanta. Delante de la caja, arranca una hoja de la libreta y se la da a la chef.

«Los doce platos salieron sin enfriarse ni una sola vez. Hubo esperas, pero nadie se quedó esperando de brazos cruzados. Volveré. La próxima vez, como clienta».

Cuando la crítica se marcha, las luces de la cocina se van apagando una a una. La chef saca del bolsillo del delantal la última tarjeta de recetas y se la da a su segundo de cocina. «Han sido doce noches. Mañana a las diez la puerta vuelve a abrirse. Esta vez te toca a ti escribir la comanda. ¿Qué vas a poner en la primera línea?».

Mirando atrás las doce noches

Ejercicios

1. Cuando hayas cumplido el objetivo en el banco de pruebas, baja los pedidos a 8 y busca, cambiando el límite de tiempo y los reintentos, si con solo 2 fogones se puede terminar en menos de 3 segundos.
2. Añade al procesador de 12-2 un descanso entre reintentos (await asyncio.sleep(0.05 * 2 ** attempt)). ¿Hay que descansar antes de tomar el fogón o después de tomarlo? Ejecuta las dos versiones y compara el tiempo.
3. Elige un programa que quieras construir y diséñalo con la tabla de 12-1 y la lista de comprobación de 12-4. Basta con escribir una línea por herramienta: cuál eliges y por qué.