Saltearse al contenido

Carreras, bloqueos y hambre

La concurrencia introduce tres fallos que el código secuencial no puede tener: dos hilos que se pisan (carrera), dos que se esperan para siempre (bloqueo mutuo) y uno que nunca consigue avanzar (hambre). Los tres comparten una propiedad que los hace peligrosos: no se reproducen de forma fiable.

Si un fallo concurrente sólo aparece a veces, no es un fallo intermitente: es un fallo que aún no has reproducido.

Ocho hilos incrementando un contador (200 000 veces cada uno sin cesión, 50 000 con ella)
Versión Resultado
Bucle apretado, sin cesión 1 600 000 de 1 600 000
Con cesión entre leer y escribir ≈50 000 de 400 000 (varía de una ejecución a otra)
Con Lock (200 000 por hilo) 1 600 000, ≈4× más lento

python mediciones/06-06-07-colas-bloqueos.py

La primera fila es la trampa y la tercera, la lección. El programa parece correcto hasta que aparece una llamada entre la lectura y la escritura; entonces pierde el 87 % de las actualizaciones.

contador += 1 no es atómico: son cuatro instrucciones de bytecode (LOAD_GLOBAL, LOAD_CONST, BINARY_OP, STORE_GLOBAL; dis.dis lo muestra). El GIL cambia de hilo entre ellos sólo en puntos concretos, y por eso el fallo depende del código que rodea la operación.

# Hilo 1 # Hilo 2
with lock_a: with lock_b:
with lock_b: with lock_a:
... ...

Cada uno tiene lo que el otro necesita, y ninguno suelta. El programa no lanza excepción, no consume CPU: se queda parado.

Tres formas de evitarlo:

  1. Orden global de candados. Todo el código toma a antes que b, siempre. Es la única solución que no depende de tiempo.
  2. Un solo candado. Si dos recursos se protegen siempre juntos, son un recurso.
  3. acquire(timeout=...). Detecta el bloqueo y falla en lugar de colgarse; no lo evita, lo convierte en error visible.

Para diagnosticarlo: py-spy dump sobre el proceso muestra las pilas de todos los hilos y el candado que espera cada uno.

Un hilo que nunca consigue el candado porque otros llegan antes. No hay bloqueo: hay progreso para unos y no para otros.

Aparece con:

  • Candados no justos. threading.Lock no garantiza orden de llegada; un hilo rápido puede adelantar siempre al mismo.
  • Lectores que no dejan escribir. Un RWLock mal implementado mantiene a los escritores esperando indefinidamente.
  • Prioridades mal puestas en un pool: las tareas largas ocupan todos los workers y las cortas esperan.
  • Contadores de métricas aproximadas. Un contador de peticiones que pierde una de cada millón es irrelevante.
  • Cachés con recálculo. Si dos hilos calculan el mismo valor, el resultado es el mismo; sólo se desperdicia trabajo.
  • Datos inmutables compartidos. Una tupla o un frozenset no necesita candado.

Dos hilos transfieren dinero entre cuentas: uno de A a B y otro de B a A, cada uno tomando el candado de la cuenta de origen y luego el de destino. Explica el bloqueo y escribe la versión correcta.

Solución

El hilo 1 toma el candado de A y espera el de B; el hilo 2 toma el de B y espera el de A. Bloqueo mutuo clásico.

La solución es un orden global: siempre se bloquean las cuentas en el mismo orden, por ejemplo por su identificador.

def transferir(origen, destino, importe):
if origen is destino:
raise ValueError("cuenta origen y destino iguales")
primera, segunda = sorted([origen, destino], key=lambda c: c.id)
with primera.lock:
with segunda.lock:
if origen.saldo < importe:
raise ValueError("saldo insuficiente")
origen.saldo -= importe
destino.saldo += importe

Detalles que importan: el sorted usa el id de la cuenta, no el objeto (los objetos no son ordenables); el saldo se comprueba dentro del candado, porque comprobarlo fuera es otra carrera; y si el importe se resta antes de comprobar, una excepción deja el dinero perdido.

La alternativa sin candados: una sola cola de transferencias procesada por un hilo. Menos concurrencia, cero bloqueos.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 19.
  • CPython 3.13: Lib/threading.py, Python/ceval_gil.c.
  • Mediciones: mediciones/06-06-07-colas-bloqueos.py.
  • 01 · El GIL: por qué no protege de las carreras.
  • 06 · Colas: el diseño que elimina el estado compartido.
  • 08 · Elegir modelo: cuándo ni siquiera hace falta concurrencia.