Saltearse al contenido

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.

La cola no acelera nada: absorbe la diferencia entre dos velocidades.

100 000 pares de poner y quitar
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.

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, put bloquea y la presión llega a quien produce, que es donde debe estar.
  • Un centinela por consumidor. Un solo None despierta a uno y deja a los demás esperando para siempre.
  • task_done() en un finally. queue.join() cuenta tareas pendientes; si una falla y no se marca, join nunca vuelve.
  • get() bloquea. Si el consumidor debe poder parar, usa get(timeout=...) y maneja Empty.
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.

  • 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.

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 queue
import threading
FIN = object()
cola = queue.Queue(maxsize=5_000) # ~10 s de margen
guardados = [] # "base de datos" de ejemplo
candado = 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 pendiente
for _ in hilos:
cola.put(FIN) # 2) un centinela por consumidor
for 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: put bloquea 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 y join() 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.

  • 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.py y mediciones/06-05-08-async-produccion.py.
  • 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.