Saltearse al contenido

El GIL

El Global Interpreter Lock es un candado que garantiza que un solo hilo ejecute bytecode de Python a la vez. No es un detalle de implementación menor: decide qué modelo de concurrencia sirve para qué, y explica la mitad de las preguntas de rendimiento que se hacen sobre el lenguaje.

El GIL serializa el bytecode, no la espera: por eso los hilos aceleran la red y no la CPU.

Cuatro tareas de CPU (contar 20 millones, cuatro veces)
Modelo Tiempo Aceleración
Serie 3.93 s 1.00×
4 hilos 3.67 s 1.07×
4 procesos 1.28 s 3.08×

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

Los hilos no aceleran: 1,07× es ruido. Los procesos sí, y no llegan a 4× por el coste de arranque y de recoger resultados. Esa es la consecuencia práctica del GIL, medida.

En cambio, con trabajo de espera:

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

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

Ahí los hilos vuelan, porque sleep libera el GIL mientras espera. El candado sólo se sostiene mientras hay bytecode ejecutándose.

El GIL protege dos cosas:

  • El contador de referencias. Cada ob_refcnt se incrementa y decrementa sin candado; con dos hilos modificándolo a la vez, un objeto podría liberarse dos veces. Un candado global por operación sería más caro que el GIL.
  • Las extensiones en C. Una extensión escrita para el GIL no necesita sincronizar sus estructuras.

El precio es que no hay paralelismo real de bytecode. La alternativa —liberar el GIL— existe desde 3.13 como build experimental (python3.13t) y en 3.14 pasa a tener soporte oficial (PEP 779), sin sustituir al build con GIL. Cambia el modelo de memoria y rompe extensiones que lo asumían.

No protege de las carreras. El GIL cambia de hilo en puntos concretos, y una operación compuesta como contador += 1 son varios bytecodes:

8 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 time.sleep(0) entre leer y escribir ≈50 000 de 400 000 (varía de una ejecución a otra)

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

La primera fila es la trampa: funciona por accidente. En un bucle apretado el intérprete sólo comprueba el cambio de hilo en el salto de vuelta, después de haber escrito. En cuanto hay una llamada entre leer y escribir, se pierden unos 350 000 incrementos.

La lección: el GIL hace la ventana estrecha, no inexistente. Un programa que «funciona» con hilos puede fallar el día que alguien añada un log.debug dentro del bucle.

  • En trabajo de E/S: esperar red, disco o base de datos lo libera.
  • En bibliotecas que lo liberan: numpy, hashlib, compresión y muchas extensiones lo sueltan durante sus bucles en C, así que sí paralelizan.
  • En procesos separados: cada uno tiene su GIL.
  • Si el programa no usa hilos. No aplica.
  • Si el cuello es la red. El GIL no interviene mientras esperas.
  • En scripts de un solo hilo, que es el 90 % del código.

Un servicio recibe 500 peticiones por segundo. Cada una hace una consulta a base de datos de 20 ms y un cálculo de 2 ms. ¿Hilos, procesos o asyncio? Razona con los números del capítulo.

Solución

Con 500 peticiones × 22 ms = 11 segundos de trabajo por segundo, el servicio no cabe en un núcleo. Pero el reparto es desigual: 10 segundos son espera (liberan el GIL) y 1 segundo es CPU (no lo libera).

  • Hilos: 20 hilos cubren la espera; la CPU se serializa en 1 segundo, que cabe en un núcleo. Sirve, con un pool grande y cuidado con el estado compartido.
  • Procesos: 1 segundo de CPU repartido en 4 procesos es 0,25 s, pero serializar datos entre procesos por petición puede costar más que el cálculo.
  • asyncio: la opción natural si el cliente de base de datos es asíncrono. Con un driver síncrono, bloquearía el bucle y sería peor que los hilos.

La respuesta depende del driver: con driver async, asyncio; con driver síncrono, hilos. Los procesos sólo si el cálculo creciera.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 19: Concurrency Models in Python.
  • CPython 3.13: Python/ceval_gil.c, Python/ceval.c (eval breaker).
  • Mediciones: mediciones/06-01-08-concurrencia.py y mediciones/06-06-07-colas-bloqueos.py.
  • 02 · Hilos: el modelo que el GIL limita.
  • 03 · Procesos: la salida cuando el trabajo es de CPU.
  • 07 · Carreras: lo que el GIL no evita.