Saltearse al contenido

Hilos

Los hilos son el modelo más viejo y el que más se usa mal. Su valor no es paralelizar: es solapar esperas. Un hilo que espera a la red libera el GIL y deja que otro avance; un hilo que calcula no deja avanzar a nadie. Entender esa distinción evita el 90 % de los usos equivocados.

Un hilo sirve para esperar, no para calcular.

200 esperas de 5 ms
Modelo Tiempo Aceleración
Serie 1.07 s 1.00×
20 hilos 0.06 s 18.7×

python mediciones/06-01-08-concurrencia.py

El límite teórico es 200 × 5 ms = 1 s de espera; con 20 hilos concurrentes debería bajar a ~50 ms. Los 60 ms medidos incluyen el arranque del pool y la coordinación: el modelo funciona casi a la perfección.

Y con CPU:

Cuatro tareas de CPU
Modelo Tiempo
Serie 3.93 s
4 hilos 3.67 s

python mediciones/06-01-08-concurrencia.py

Sin ganancia. Ese es el GIL, y es la razón por la que los hilos no se usan para calcular.

from concurrent.futures import ThreadPoolExecutor, as_completed
with ThreadPoolExecutor(max_workers=20) as pool:
futuros = [pool.submit(descargar, url) for url in urls]
for f in as_completed(futuros):
print(f.result())

Es mejor que crear Thread a mano: gestiona el ciclo de vida, propaga excepciones por future.result() y espera en el with. Crear hilos sueltos y olvidarse de join() es la causa número uno de procesos que no terminan.

El número de workers no es «cuántos quiero» sino «cuántas esperas simultáneas tolero»: para red, entre 10 y 50; para disco, menos.

Adquirir y liberar un Lock
Operación Coste
with lock: 123 ns
Bloque vacío sin lock 11 ns

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

Ciento veinte nanosegundos por sección crítica. Si el trabajo protegido es menor que eso, el candado cuesta más que el problema: agrupa operaciones en lugar de bloquear por elemento.

  1. Comparte lo menos posible. Un hilo que recibe sus datos y devuelve un resultado no necesita candados.
  2. Un candado por recurso, no uno global. Un candado global convierte el programa en serie.
  3. Ordena los candados siempre igual. Si dos hilos toman A y B en distinto orden, se bloquean mutuamente (capítulo 07).
  4. Nunca hagas E/S dentro de un candado. Una consulta de 20 ms con el candado tomado paraliza a todos.
  • Para cálculo puro. Procesos (capítulo 03).
  • Con muchas conexiones simultáneas (miles). Cada hilo reserva unos 2,9 MB de pila en Windows x64 (8 MB en Linux); asyncio escala mejor.
  • Si el estado compartido es complejo. Un candado mal puesto es peor que un proceso.
  • En código que ya es rápido. Añadir hilos a un bucle de 10 ms es añadir fallos sin ganancia.

Un script descarga 500 URLs de 2 MB cada una y tarda 8 minutos en serie. Estima el tiempo con 20 hilos y explica qué límites aparecen antes que la CPU.

Solución

Si cada descarga tarda ~1 s (2 MB por una conexión doméstica), 500 s en serie. Con 20 hilos concurrentes, el tiempo baja a ~25 s más el arranque.

Los límites que aparecen, en orden:

  1. El ancho de banda. 500 × 2 MB = 1 GB; a 100 Mbps son 80 s como mínimo. Con 20 hilos no se descarga más rápido que la línea.
  2. El servidor remoto. Puede limitar conexiones por IP y devolver 429. Los hilos no ayudan; un límite de concurrencia sí.
  3. La memoria. 20 descargas simultáneas de 2 MB son 40 MB en vuelo; con 500 hilos serían 1 GB.

La CPU nunca es el límite. Por eso este es el caso de uso canónico de hilos (o de asyncio, que escala mejor a miles).

Las cuentas, para comprobarlas:

urls, mb, segundos_por_url, hilos = 500, 2, 1.0, 20
print(f"en serie: {urls * segundos_por_url:.0f} s")
print(f"con {hilos} hilos (sin limites): {urls * segundos_por_url / hilos:.0f} s")
total_mbit = urls * mb * 8
print(f"datos: {urls * mb / 1000:.1f} GB; a 100 Mbps, minimo {total_mbit / 100:.0f} s")
print(f"en vuelo con {hilos} hilos: {hilos * mb} MB; con {urls} hilos: {urls * mb} MB")
  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 19 y 20.
  • CPython 3.13: Lib/threading.py, Modules/_threadmodule.c.
  • Mediciones: mediciones/06-01-08-concurrencia.py y mediciones/06-06-07-colas-bloqueos.py.
  • 01 · El GIL: por qué no aceleran la CPU.
  • 03 · Procesos: cuando el trabajo es de cálculo.
  • 07 · Carreras y bloqueos: los fallos que introducen.