Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

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 lectura 3 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.

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]


def prepara(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 in enumerate(titulos)
]

for hilo in hilos:
    hilo.start()
for hilo in hilos:
    hilo.join()

print(resultados)
print(threading.active_count())
$ python main.py
['COMPRAR PAN', 'LLAMAR AL BANCO', 'REPASAR PYTHON']
1
  1. target es la función que ejecuta el hilo y args son sus argumentos (en una tupla).
  2. start() lo pone en marcha y vuelve enseguida: el hilo corre por su cuenta.
  3. join() bloquea hasta que ese hilo acaba. Con todos los join hechos, ya puedes leer resultados con tranquilidad.
  4. 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 proceso
print("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é
1Esperando la red, el disco o la base de datos (E/S)SíMientras un hilo espera suelta el GIL y otro avanza
2Calculando sin parar (CPU: imágenes, números, hashes)NoSolo 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
def marca_hecha(estado):
    leido = estado["hechas"]
    yield
    estado["hechas"] = leido + 1


def reparte(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"))
  1. Con el orden AABB, el hilo A lee 0, guarda 1, y luego B lee 1 y guarda 2. Resultado correcto.
  2. Con ABAB, los dos leen 0 antes de que nadie guarde. Cada uno guarda 0 + 1. Resultado: 1. Una tarea hecha se ha perdido.
  3. 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()


def marca_hechas(veces):
    global contador
    for _ in range(veces):
        with cerrojo:
            contador += 1


hilos = [threading.Thread(target=marca_hechas, args=(10_000,)) for _ in range(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ónEstado del modo sin GILQué significa
1Python 3.13Experimental (PEP 703)Existe una compilación aparte (python3.13t) para probar
2Python 3.14Oficialmente soportado (PEP 779)Ya no es experimental, pero es una compilación opcional; la normal sigue con GIL
3Python 3.15Sigue siendo opcionalMejora el soporte (p. ej. los instaladores oficiales de macOS lo incluyen), pero no es el modo por defecto
  1. En el Python de siempre (el que instala apt, brew o el instalador de python.org por defecto) sigue habiendo GIL.
  2. 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.
  3. 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.
  4. 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.
  5. 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
<?php
declare(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 {
    return strtoupper($titulo);
}, ["comprar pan"]);

echo $futuro->value() . PHP_EOL;
Pythonmain.pySolo lectura: necesita hilos del sistema
import threading

resultado = []


def mayusculas(titulo):
    resultado.append(titulo.upper())


hilo = threading.Thread(target=mayusculas, args=("comprar pan",))
hilo.start()
hilo.join()

print(resultado[0])
  1. 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.
  2. En Python los hilos vienen en la biblioteca estándar: threading está siempre.
  3. Los dos arrancan trabajo en paralelo y esperan su resultado (value() y join()).

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

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

Resumen

Lo que te llevas de esta lección

  1. 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).
  2. 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.
  3. contador += 1 no es un solo paso: sin un threading.Lock (con with), dos hilos pueden pisarse y perder cuentas, sin dar error.
  4. 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.
  5. 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.