Wat is de GIL en hoe beïnvloedt deze gelijktijdigheid?

Question

Accepted Answer

De **GIL** (Global Interpreter Lock) is een mutex in CPython (de standaard Python-implementatie) die slechts **één thread tegelijk Python bytecode laat uitvoeren**. Dit betekent dat Python-threads Python-code niet echt parallel op meerdere CPU-kernen kunnen uitvoeren — een belangrijke overweging voor gelijktijdigheid.

## Wat de GIL in de praktijk betekent

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

## Het belangrijkste onderscheid: 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
```

De cruciale nuance: de GIL wordt **vrijgegeven tijdens I/O** (netwerk, bestand, sleep) en in veel C-extensies. Dus threads *helpen wel* bij **I/O-bound** werk (meerdere wachttijden overlappen), maar *niet* bij **CPU-bound** werk (de GIL serialiseert de berekening).

## De GIL omzeilen voor CPU-bound werk

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

Voor CPU-bound parallellisme, gebruik **`multiprocessing`** (aparte processen ontsnappen aan de enkele GIL), of bibliotheken (NumPy, enzovoort) waarvan het zware werk in C met de GIL vrijgegeven wordt.

## De besluitvormingsgids

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

## De toekomst

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

## Waarom het belangrijk is

De GIL is een van Python's belangrijkste — en meest misverstane — karakteristieken.

Het verklaart *waarom* het gebruik van threads voor CPU-intensief werk geen versnelling oplevert (een veelgemaakte fout), en *waarom* het juiste gelijktijdigheidshulpmiddel afhankelijk is van de werkbelasting: **threading/asyncio voor I/O-bound** (waar de GIL wordt vrijgegeven tijdens wachten) en **multiprocessing voor CPU-bound** (aparte processen voor echte parallellisme).

Misverstaan van de GIL leidt tot ineffectieve gelijktijdige code die niet schaalt.

Ernaar kennen — en de I/O-vs-CPU-beslissing die het aandrijft — is essentieel voor het schrijven van gelijktijdige Python die werkelijk presteert.