¿Qué es el GIL y cómo afecta a la concurrencia?

Question

Accepted Answer

El **GIL** (Global Interpreter Lock, bloqueo global del intérprete) es un mutex de CPython (la implementación estándar de Python) que permite que solo **un hilo ejecute bytecode de Python a la vez**. Esto significa que los hilos de Python no pueden ejecutar código Python en paralelo real sobre múltiples núcleos de CPU, una consideración importante para la concurrencia.

## Qué significa el GIL en la práctica

```text
Even with multiple threads on a multi-core CPU:
  Only ONE thread runs Python bytecode at any instant.
→ Threading does NOT give CPU-bound parallelism in CPython.
```

## La distinción clave: trabajo de CPU vs trabajo de I/O

```python
import threading

# ❌ CPU-bound work with threads — NO speedup (GIL serializes them)
def cpu_task():
    sum(i * i for i in range(10_000_000))   # heavy computation
# 4 threads doing this run essentially as slow as 1 (GIL contention)

# ✅ I/O-bound work with threads — REAL benefit
def io_task():
    response = requests.get(url)   # waits on network — RELEASES the GIL while waiting
# while one thread waits on I/O, the GIL is freed for others → concurrency works
```

El matiz crucial: el GIL se **libera durante el I/O** (red, archivos, sleep) y dentro de muchas extensiones en C. Por eso los hilos *sí* ayudan para el trabajo **limitado por I/O** (varias esperas se solapan), pero *no* para el trabajo **limitado por CPU** (el GIL serializa el cómputo).

## Sortear el GIL para trabajo limitado por CPU

```python
from multiprocessing import Pool

# ✅ multiprocessing uses separate PROCESSES, each with its own GIL → true parallelism
with Pool(4) as p:
    results = p.map(cpu_task, data)   # runs on 4 cores genuinely in parallel
```

Para el paralelismo limitado por CPU, usa **`multiprocessing`** (procesos separados que esquivan el GIL único), o librerías (NumPy, etc.) cuyo trabajo pesado se ejecuta en C con el GIL liberado.

## La guía de decisión

```text
I/O-bound (network, files, DB)  → threading or asyncio (GIL released on I/O)
CPU-bound (computation)          → multiprocessing (or C-extension libraries)
```

## El futuro

```text
Python 3.13+ introduces an EXPERIMENTAL free-threaded (no-GIL) build,
and work continues to reduce the GIL's impact — but it remains the default reality.
```

## Por qué es importante

El GIL es una de las características más importantes —y peor comprendidas— de Python.

Explica *por qué* usar hilos para trabajo intensivo en CPU no aporta aceleración (un error común) y *por qué* la herramienta de concurrencia correcta depende de la carga de trabajo: **threading/asyncio para trabajo limitado por I/O** (donde el GIL se libera durante las esperas) y **multiprocessing para trabajo limitado por CPU** (procesos separados para paralelismo real).

Malinterpretar el GIL conduce a código concurrente ineficaz que no escala.

Conocerlo —y la decisión I/O-vs-CPU que impulsa— es esencial para escribir Python concurrente que realmente rinda.