Što je GIL i kako utječe na paralelnost?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) je mutex u CPython-u (standardnoj Python implementaciji) koji omogućava samo **jednoj niti da izvršava Python bytecode odjednom**. To znači da Python niti ne mogu pokrenuti Python kod u pravoj paralelnosti na više jezgara CPU-a — važna razmatranja za paralelnost.

## Što GIL znači u praksi

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

## Ključna razlika: CPU-vezana vs I/O-vezana

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

Odmah važna nijansa: GIL se **oslobađa tijekom I/O operacija** (mreža, datoteka, sleep) i unutar mnogih C proširenja. Dakle, niti *pomažu* za **I/O-vezane** zadatke (više čekanja se preklapa), ali *ne* za **CPU-vezane** zadatke (GIL serijalizira izračune).

## Zaobilaženje GIL-a za CPU-vezene zadatke

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

Za CPU-vezanu paralelnost koristite **`multiprocessing`** (odvojeni procesi izbjegavaju pojedinačni GIL), ili biblioteke (NumPy, itd.) čiji teški rad se izvršava u C-u s oslobođenim GIL-om.

## Vodiču za odluke

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

## Budućnost

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

## Zašto je to važno

GIL je jedna od Python-ovih najvažnijih — i najpogrešnije razumljenih — karakteristika.

Objašnjava *zašto* korištenje niti za CPU-intenzivne zadatke ne daje ubrzanja (česta greška), i *zašto* pravi alat za paralelnost ovisi o vrsti posla: **niti/asyncio za I/O-vezane** (gdje se GIL oslobađa tijekom čekanja) i **multiprocessing za CPU-vezane** (odvojeni procesi za pravu paralelnost).

Misunderstanding GIL-a dovodi do neučinkovitog paralelnog koda koji se ne skalira.

Znanje toga — i I/O-naspram-CPU odluka koju on vodi — bitno je za pisanje paralelnog Python koda koji doista funkcionira.