Lección 33 de 47 · Concurrencia: hilos, procesos y async✦ WebMCP implementado
Hilos y el GIL (y el modo free-threaded de 3.14)
10 min de lectura3 retos
Un hilo es un cocinero extra dentro de tu mismo programa. Python los tiene desde siempre, pero con una trampa famosa: el GIL, que deja trabajar a uno solo cada vez. Aquí ves qué es un hilo, qué hace el GIL, por qué un contador compartido se estropea sin un candado y qué cambia con el modo free-threaded de Python 3.13 y 3.14.
¿De dónde vienen los nombres?
threading = inglés thread (hilo, como el de coser) + -ing
Un «hilo de ejecución» es un camino por el código que avanza a su ritmo. Un programa puede llevar varios hilos a la vez, como varios hilos cosidos en la misma tela.
join = inglés join (unir)
«Espero aquí a que ese hilo termine y me uno a él.» Es el wait de los hilos: sin join, tu programa puede acabar antes que ellos.
GIL = Global Interpreter Lock (cerrojo global del intérprete)
Un candado único que lleva el intérprete de Python (CPython). Quien lo tiene ejecuta código Python; los demás hilos esperan su turno.
Lock = inglés lock (candado, cerradura)
Un candado que pones tú: solo un hilo puede estar dentro de la zona que protege, el resto espera fuera.
condición de carrera (race condition) = inglés race (carrera) condition (situación)
Dos hilos corren hacia el mismo dato y el resultado depende de quién llega antes. Cambia de una ejecución a otra, y por eso es tan difícil de cazar.
En 4 ideas
1/4
Un hilo es un cocinero más en la misma cocina: comparte con los demás la memoria del programa. En PHP clásico no hay hilos en tu script web: cada petición es un proceso aparte.
En CPython (el Python normal) el GIL deja que un solo hilo ejecute código Python a la vez. Los hilos sirven para esperar (red, disco, base de datos), no para calcular más rápido.
El GIL protege el intérprete, no tu lógica: contador += 1 son varios pasos y otro hilo se puede colar entre ellos. Para eso existe threading.Lock (en PHP no hay equivalente porque no compartes memoria entre peticiones).
Python 3.13 estrenó una compilación sin GIL (free-threaded), en 3.14 pasó a ser oficial y sigue siendo opcional: el Python que instalas por defecto aún lleva GIL.
1 · Un hilo es un cocinero más en la misma cocina
Recuerda el restaurante de la lección anterior. Un hilo es otro cocinero que entra en tu misma cocina: usa los mismos fuegos, la misma despensa y la misma nevera. Si uno guarda un tarro en la nevera, el otro lo ve. Eso es muy cómodo (compartes datos sin copiar nada) y muy peligroso (os podéis pisar), como verás en un momento.
Se crea con threading.Thread, se arranca con start() y se espera con join(). Este programa reparte tres títulos entre tres hilos. Como pasa por join antes de imprimir, la salida es siempre la misma:
Pythonmain.pySolo lectura: necesita hilos del sistema
import threading
resultados = [None, None, None]
defprepara(posicion, titulo):
resultados[posicion] = titulo.upper()
titulos = ["comprar pan", "llamar al banco", "repasar python"]
hilos = [
threading.Thread(target=prepara, args=(i, titulo))
for i, titulo inenumerate(titulos)
]
for hilo in hilos:
hilo.start()
for hilo in hilos:
hilo.join()
print(resultados)
print(threading.active_count())
target es la función que ejecuta el hilo y args son sus argumentos (en una tupla).
start() lo pone en marcha y vuelve enseguida: el hilo corre por su cuenta.
join() bloquea hasta que ese hilo acaba. Con todos los join hechos, ya puedes leer resultados con tranquilidad.
threading.active_count() vale 1 al final: solo queda el hilo principal.
2 · El GIL: un solo hilo ejecuta Python a la vez
Aquí viene la trampa. En CPython, el intérprete oficial, hay un candado global: el GIL. Aunque tengas 8 núcleos y 8 hilos, solo uno ejecuta instrucciones de Python en cada momento. Los demás esperan. Cada pocos milisegundos (sys.getswitchinterval() vale 0,005 s por defecto) el candado pasa a otro hilo.
Pythonmain.py
import sys
# En PHP: no hay equivalente; cada peticion corre en su procesoprint("tiempo entre turnos:", sys.getswitchinterval(), "s")
# _is_gil_enabled existe desde Python 3.13
con_gil = getattr(sys, "_is_gil_enabled", lambda: True)()
print("¿hay GIL?", con_gil)
¿Por qué? · En PHP no existe
¿Por qué tiene Python un GIL? En PHP no existe
CPython lleva la cuenta de cuántas variables apuntan a cada objeto (el contador de referencias): cuando llega a cero, libera la memoria. Esa cuenta es un número que cambia muy a menudo.
Si dos hilos tocaran el mismo contador a la vez, podrían estropearlo y borrar un objeto que aún se usa, o dejarlo en memoria para siempre. Proteger cada objeto con su candado sería lento y complicado, así que los creadores de Python eligieron un candado para todo el intérprete: simple y rápido para un solo hilo, y las extensiones en C se escriben más fácil.
PHP no necesita nada parecido porque, en una petición normal, no hay varios hilos tocando tus datos: cada petición tiene los suyos.
Entonces, ¿para qué sirven los hilos? Para esperar. Cuando un hilo hace una llamada que espera (leer un fichero, una respuesta de red, un time.sleep), suelta el GIL y deja pasar a otro. Mientras uno espera al disco, otro trabaja.
#
Tu tarea pasa el tiempo…
¿Ayudan los hilos (con GIL)?
Por qué
1
Esperando la red, el disco o la base de datos (E/S)
Sí
Mientras un hilo espera suelta el GIL y otro avanza
2
Calculando sin parar (CPU: imágenes, números, hashes)
No
Solo un hilo ejecuta Python a la vez; los demás hacen cola
3 · La carrera de datos: el GIL no protege tu lógica
Mucha gente piensa: «Si solo corre un hilo a la vez, no me pasará nada». Falso. El GIL cambia de hilo en cualquier momento entre dos instrucciones, también en mitad de tu operación. Y algo tan corto como hechas += 1 son tres pasos: leer el valor, sumarle uno y guardarlo.
Veámoslo sin hilos reales, repartiendo los turnos a mano con generadores (cada yield es «aquí el sistema puede cambiar de hilo»). Los dos hilos quieren marcar una tarea como hecha:
Pythonmain.py
defmarca_hecha(estado):
leido = estado["hechas"]
yield
estado["hechas"] = leido + 1defreparte(orden):
estado = {"hechas": 0}
hilos = {"A": marca_hecha(estado), "B": marca_hecha(estado)}
for letra in orden:
next(hilos[letra], None)
return estado["hechas"]
print("A termina y luego B:", reparte("AABB"))
print("A y B se cruzan:", reparte("ABAB"))
Con el orden AABB, el hilo A lee 0, guarda 1, y luego B lee 1 y guarda 2. Resultado correcto.
Con ABAB, los dos leen 0antes de que nadie guarde. Cada uno guarda 0 + 1. Resultado: 1. Una tarea hecha se ha perdido.
Ningún hilo ha fallado ni ha dado error: simplemente el dato quedó mal. Eso es una condición de carrera.
La cura es un candado: threading.Lock. Solo un hilo puede estar dentro del bloque with cerrojo:; los demás esperan a que salga. Con el candado, el total sale siempre bien:
Pythonmain.pySolo lectura: necesita hilos del sistema
import threading
contador = 0
cerrojo = threading.Lock()
defmarca_hechas(veces):
global contador
for _ inrange(veces):
with cerrojo:
contador += 1
hilos = [threading.Thread(target=marca_hechas, args=(10_000,)) for _ inrange(4)]
for hilo in hilos:
hilo.start()
for hilo in hilos:
hilo.join()
print(contador)
$ python main.py
40000
¿Por qué? · En PHP no existe
¿Por qué hace falta un Lock si ya hay un GIL?
Porque son dos candados para dos cosas. El GIL protege el intérprete (que no se rompan sus contadores y estructuras internas). Tu Lock protege tus datos y tu lógica (que dos pasos seguidos no se mezclen con los de otro hilo).
Sin el Lock, el programa de arriba a veces daría 40000 y a veces menos, sin avisar: es el peor tipo de fallo, porque no se repite. Por eso en el examen de este módulo no verás un bug de «a veces»: los reproducimos a mano, con turnos fijos.
4 · El modo free-threaded: Python sin GIL
El GIL lleva décadas siendo la queja número uno. La comunidad Python lo ha atacado con una versión sin GIL, llamada free-threaded («hilos libres»). Lo que puedes afirmar hoy:
#
Versión
Estado del modo sin GIL
Qué significa
1
Python 3.13
Experimental (PEP 703)
Existe una compilación aparte (python3.13t) para probar
2
Python 3.14
Oficialmente soportado (PEP 779)
Ya no es experimental, pero es una compilación opcional; la normal sigue con GIL
3
Python 3.15
Sigue siendo opcional
Mejora el soporte (p. ej. los instaladores oficiales de macOS lo incluyen), pero no es el modo por defecto
En el Python de siempre (el que instala apt, brew o el instalador de python.org por defecto) sigue habiendo GIL.
El de hilos libres es otra compilación del intérprete. Con ella, dos hilos que calculan sí pueden usar dos núcleos a la vez.
Puedes preguntar en qué modo estás con sys._is_gil_enabled() (existe desde 3.13) y forzar el GIL con la variable de entorno PYTHON_GIL=1.
No es gratis: en 3.14, sus propios autores calculan que el código de un solo hilo va entre un 5 % y un 10 % más lento que en la compilación normal, según plataforma y compilador.
Las bibliotecas escritas en C tienen que declararse compatibles. Si una no lo está, Python puede volver a activar el GIL al importarla.
Y el navegador de este curso corre una versión normal de Python sobre WebAssembly (sin hilos del sistema), de ahí que los ejemplos con threading sean de solo lectura. Compáralo con PHP:
PHP 8.5parallel.php
<?phpdeclare(strict_types=1);
// Solo con PHP ZTS + la extension parallel (no viene de serie)$runtime = new \parallel\Runtime();
$futuro = $runtime->run(function (string $titulo): string {
returnstrtoupper($titulo);
}, ["comprar pan"]);
echo$futuro->value() . PHP_EOL;
Pythonmain.pySolo lectura: necesita hilos del sistema
En PHP los hilos no existen en un script web normal; hace falta una compilación ZTS (Zend Thread Safety) con la extensión parallel, y casi nadie la usa en producción.
En Python los hilos vienen en la biblioteca estándar: threading está siempre.
Los dos arrancan trabajo en paralelo y esperan su resultado (value() y join()).
Hora de practicar
Retos · 0/3 resueltos
Reto 1 de 3 · ✓ Resuelto
Dos hilos que se pisan
Tienes dos «hilos» simulados con generadores: a y b marcan una tarea como hecha en el diccionario estado. Ahora los turnos van uno detrás de otro y el resultado sale 2. Cambia el reparto de turnos (las cuatro llamadas a next) para que se crucen, de modo que los dos lean antes de guardar y el programa imprima 1: la tarea hecha que se pierde.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. El orden a, b, a, b hace que A y B lean 0 antes de que nadie guarde.
Reto 2 de 3 · ✓ Resuelto
El planificador a mano
Escribe simula(orden). orden es un texto con las letras A y B (por ejemplo "ABAB"): cada letra es un turno que se da al hilo A o B, avanzándolo un paso con next(hilo, None). Ya tienes marca_hecha (el hilo que lee, cede el turno y guarda). Devuelve cuántas tareas hechas quedan en el estado. simula("AABB") da 2; simula("ABAB") da 1. Es lo que hace el sistema operativo con los hilos de verdad.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Un diccionario {"A": marca_hecha(estado), "B": marca_hecha(estado)} y un for letra in orden: con next(hilos[letra], None).
Reto 3 de 3 · ✓ Resuelto
El turno del GIL
Simula cómo el GIL reparte el tiempo. turnos(trabajos, cuanto) recibe un diccionario {nombre: pasos que le faltan} y un cuanto (los pasos que cada hilo puede dar por turno). Se reparte en rueda: cada uno avanza cuanto pasos y, si aún le faltan, vuelve al final de la cola. Devuelve la lista con los nombres en el orden en que terminan. turnos({"a": 5, "b": 2, "c": 3}, 2) da ["b", "c", "a"].
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.while cola:, nombre, faltan = cola.popleft(), resta cuanto; si faltan <= 0 termina, si no, cola.append((nombre, faltan)).
Resumen
Lo que te llevas de esta lección
Un hilo comparte la memoria del programa con los demás (en PHP clásico, cada petición es un proceso aparte y no se ve con las otras).
El GIL de CPython deja a un solo hilo ejecutar Python a la vez: los hilos ayudan a esperar (E/S), no a calcular más rápido.
contador += 1 no es un solo paso: sin un threading.Lock (con with), dos hilos pueden pisarse y perder cuentas, sin dar error.
El free-threaded (sin GIL) es experimental en 3.13, oficial pero opcional en 3.14 y 3.15, y no es el Python por defecto; con él los Lock hacen más falta.
Los ejemplos con threading de este curso son de solo lectura: el navegador no tiene hilos del sistema.
Para recordarlo: «Hilos Esperan, Procesos Calculan»
HHilos esperan: red, disco, base de datos
LLock with cerrojo: para tocar datos compartidos
GGIL uno solo ejecuta Python a la vez
Con GIL, los hilos sirven para Esperar. Para Calcular en paralelo, la siguiente lección: procesos.