Colas y productor/consumidor
Una cola hace dos cosas: desacopla la velocidad del productor de la del consumidor, y convierte un problema de concurrencia en un problema de mensajes. Es la estructura que aparece en todo sistema que procesa más de lo que puede atender en el momento.
En una línea
Sección titulada «En una línea»La cola no acelera nada: absorbe la diferencia entre dos velocidades.
Lo que cuesta
Sección titulada «Lo que cuesta»| Estructura | Coste por par |
|---|---|
deque.append + popleft |
0.06 µs |
asyncio.Queue |
0.64 µs |
queue.Queue |
1.21 µs |
python mediciones/06-06-07-colas-bloqueos.py
Veinte veces más que un deque, y es razonable: queue.Queue toma un candado en cada operación y notifica a las condiciones. Un deque no es seguro entre hilos y no bloquea cuando está vacío, que es justo lo que necesitas.
La regla: deque para una cola de un solo hilo; queue.Queue para hilos; asyncio.Queue para corrutinas. Mezclarlas es la fuente de la mitad de los bloqueos.
El patrón
Sección titulada «El patrón»import queue, threading
tareas: queue.Queue = queue.Queue(maxsize=100)fin = object()
def productor(): for item in fuente(): tareas.put(item) for _ in range(NUM_CONSUMIDORES): tareas.put(fin) # un centinela por consumidor
def consumidor(): while True: item = tareas.get() try: if item is fin: return procesar(item) finally: tareas.task_done()Cuatro detalles que separan esto de una versión que se cuelga:
maxsize. Sin límite, el productor llena la memoria si el consumidor es más lento. Con límite,putbloquea y la presión llega a quien produce, que es donde debe estar.- Un centinela por consumidor. Un solo
Nonedespierta a uno y deja a los demás esperando para siempre. task_done()en unfinally.queue.join()cuenta tareas pendientes; si una falla y no se marca,joinnunca vuelve.get()bloquea. Si el consumidor debe poder parar, usaget(timeout=...)y manejaEmpty.
Productor/consumidor con asyncio
Sección titulada «Productor/consumidor con asyncio»cola: asyncio.Queue = asyncio.Queue(maxsize=100)
async def productor(): async for item in fuente(): await cola.put(item) # bloquea si está llena: contrapresión
async def consumidor(): while True: item = await cola.get() await procesar(item)Es el mismo patrón con await en lugar de bloqueo. La diferencia importante es que la contrapresión funciona de verdad: cuando la cola está llena, el productor se suspende y deja correr al consumidor.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si el productor y el consumidor van a la misma velocidad. Una llamada directa es más simple y más rápida.
- Si sólo hay un elemento. Una variable y un
Event. - Si necesitas resultado inmediato. Una cola desacopla, y desacoplar significa que no sabes cuándo termina.
- Entre procesos. Ahí es
multiprocessing.Queue, con serialización: mucho más caro.
Ejercicio
Sección titulada «Ejercicio»Un servicio recibe 2 000 eventos por segundo y los escribe en una base de datos que aguanta 500 por segundo. Diseña la cola: tamaño, número de consumidores, qué pasa cuando se llena y cómo se para el servicio sin perder eventos.
Solución
import queueimport threading
FIN = object()cola = queue.Queue(maxsize=5_000) # ~10 s de margenguardados = [] # "base de datos" de ejemplocandado = threading.Lock()
def insertar(evento): with candado: guardados.append(evento)
def consumidor(): while True: evento = cola.get() try: if evento is FIN: return insertar(evento) finally: cola.task_done()
hilos = [threading.Thread(target=consumidor) for _ in range(4)]for h in hilos: h.start()for n in range(1_000): # productor: put bloquea si la cola se llena cola.put(n)cola.join() # 1) se vacía lo pendientefor _ in hilos: cola.put(FIN) # 2) un centinela por consumidorfor h in hilos: h.join()print(f"eventos guardados: {len(guardados)}")print(f"suma de ids: {sum(guardados)}")assert sorted(guardados) == list(range(1_000)), "se perdió o duplicó algún evento"- Tamaño: 5 000, unos diez segundos de amortiguación. Más grande retrasa la detección del problema; más pequeño rechaza picos normales.
- Consumidores: 4 hilos, porque la base es el cuello (500/s). Más consumidores sólo añaden contención en la base.
- Cuando se llena:
putbloquea al productor, que es lo correcto: la presión debe llegar a quien genera, no acumularse en memoria. Si el productor no puede bloquear (un servidor HTTP), descarta eventos con una métrica explícita en lugar de crecer. - Parada ordenada: dejar de aceptar, esperar a que
cola.join()vuelva, luego poner un centinela por consumidor yjoin()de los hilos.
Lo que no se hace: maxsize=0 (ilimitada) con la esperanza de que la base aguante. Cuando no aguanta, el proceso muere con la memoria llena y se pierden los eventos en vuelo.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulos 19 y 20.
- CPython 3.13:
Lib/queue.py,Lib/asyncio/queues.py. - Mediciones:
mediciones/06-06-07-colas-bloqueos.pyymediciones/06-05-08-async-produccion.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · Hilos: el modelo donde vive
queue.Queue. - 05 · asyncio en producción: el mismo patrón sin hilos.
- 07 · Carreras y bloqueos: los fallos que el patrón evita.