Cos'è il GIL e come influisce la concorrenza?

Question

Accepted Answer

Il **GIL** (Global Interpreter Lock) è un mutex in CPython (l'implementazione standard di Python) che consente a **un solo thread di eseguire Python bytecode alla volta**. Ciò significa che i thread Python non possono eseguire codice Python in vera concorrenza su più core CPU — una considerazione importante per la concorrenza.

## Cosa significa il GIL in pratica

```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 distinzione chiave: 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
```

La sfumatura cruciale: il GIL viene **rilasciato durante l'I/O** (rete, file, sleep) e dentro molte estensioni C. Quindi i thread *aiutano* il lavoro **I/O-bound** (più attese si sovrappongono), ma *non* il lavoro **CPU-bound** (il GIL serializza il calcolo).

## Aggirare il GIL per il lavoro 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
```

Per il parallelismo CPU-bound, usa **`multiprocessing`** (processi separati aggirano il singolo GIL), o librerie (NumPy, ecc.) il cui lavoro pesante viene eseguito in C con il GIL rilasciato.

## La guida alle decisioni

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

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

## Perché è importante

Il GIL è una delle caratteristiche più importanti — e più incomprese — di Python.

Spiega *perché* l'uso di thread per il lavoro CPU-intensivo non fornisce accelerazione (un errore comune), e *perché* lo strumento di concorrenza corretto dipende dal carico di lavoro: **threading/asyncio per I/O-bound** (dove il GIL viene rilasciato durante le attese) e **multiprocessing per CPU-bound** (processi separati per vera concorrenza).

Non comprendere il GIL porta a codice concorrente inefficace che non scala.

Conoscerlo — e la decisione I/O-vs-CPU che guida — è essenziale per scrivere codice Python concorrente che effettivamente funziona.