Ce este GIL și cum afectează el concurrency-ul?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) este un mutex în CPython (implementarea standard Python) care permite doar **unui singur thread să execute bytecode Python la o dată**. Aceasta înseamnă că thread-urile Python nu pot rula cod Python în paralelism adevărat pe mai multe nuclee CPU — o considerație majoră pentru concurrency.

## Ce înseamnă GIL în practică

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

## Distincția esențială: 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
```

Nuanța crucială: GIL este **eliberat în timpul I/O** (rețea, fișier, sleep) și în interiorul multor extensii C. Deci thread-urile *fac* ajută pentru lucrare **I/O-bound** (multiple așteptări se suprapun), dar *nu* pentru lucrare **CPU-bound** (GIL serializează calculul).

## Ocolirea GIL pentru lucrare 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
```

Pentru paralelism CPU-bound, utilizați **`multiprocessing`** (procese separate ocolesc GIL-ul unic), sau biblioteci (NumPy, etc.) al căror lucru greu rulează în C cu GIL eliberat.

## Ghidul deciziei

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

## Viitorul

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

## De ce contează

GIL este una dintre cele mai importante — și cele mai neînțelese — caracteristici ale Python.

Explică *de ce* utilizarea thread-urilor pentru lucrare CPU-intensivă nu oferă accelerare (o greșeală comună), și *de ce* instrumentul concurrency corect depinde de sarcina de lucru: **threading/asyncio pentru I/O-bound** (unde GIL este eliberat în timpul așteptărilor) și **multiprocessing pentru CPU-bound** (procese separate pentru paralelism adevărat).

Neînțelegerea GIL duce la cod concurrency ineficace care nu se scalează.

A-l cunoaște — și decizia I/O-vs-CPU pe care o determină — este esențial pentru a scrie Python concurrency care chiar funcționează.