O que é o GIL e como afeta a concorrência?

Question

Accepted Answer

O **GIL** (Global Interpreter Lock) é um mutex em CPython (a implementação padrão de Python) que permite **apenas uma thread executar bytecode Python por vez**. Isso significa que threads Python não podem executar código Python em verdadeiro paralelismo em múltiplos núcleos de CPU — uma consideração importante para concorrência.

## Por que isso importa

```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.
```

## A distinção fundamental: CPU-bound vs I/O-bound

```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
```

A nuance crucial: o GIL é **liberado durante I/O** (rede, arquivo, sleep) e dentro de muitas extensões C. Então threads *fazem* ajudar para trabalho **I/O-bound** (múltiplas esperas se sobrepõem), mas *não* para trabalho **CPU-bound** (o GIL serializa computação).

## Contornando o GIL para trabalho CPU-bound

```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 paralelismo CPU-bound, use **`multiprocessing`** (processos separados contornam o GIL único) ou bibliotecas (NumPy, etc.) cujo trabalho pesado é executado em C com o GIL liberado.

## Guia de decisão

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

## O 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 que isso importa

O GIL é uma das características mais importantes — e mais incompreendidas — de Python.

Explica *por que* usar threads para trabalho pesado de CPU não oferece ganho de velocidade (um erro comum), e *por que* a ferramenta de concorrência correta depende da carga de trabalho: **threading/asyncio para I/O-bound** (onde o GIL é liberado durante esperas) e **multiprocessing para CPU-bound** (processos separados para verdadeiro paralelismo).

Mal-entender o GIL leva a código concorrente ineficaz que não escala.

Conhecê-lo — e a decisão I/O-vs-CPU que impulsiona — é essencial para escrever Python concorrente que realmente funciona.