Kaj je GIL in kako vpliva na sočasnost?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) je mutex v CPython-u (standardna implementacija Pythona), ki omogoči samo **enemu nitju, da izvaja Python bytecode naenkrat**. To pomeni, da Python niti ne morejo izvajati Python kode v pravi vzporednosti na več CPU jedrah — pomembna premislitev za sočasnost.

## Kaj GIL pomeni v 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-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
```

Odločujoča nuansa: GIL je **izpuščen med I/O** (omrežje, datoteka, sleep) in v mnogih C razširitvah. Zato niti *dejansko pomagajo* pri **I/O-bound** delu (več čakanj se prekriva), vendar *ne* pri **CPU-bound** delu (GIL serijalizira izračun).

## Obhod GIL-a za CPU-bound delo

```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-bound paralelizem uporabite **`multiprocessing`** (ločeni procesi zaobidejo enoten GIL) ali knjižnice (NumPy itd.), katerih intenzivno delo teče v C z izpuščenim GIL-om.

## Vodnik odločanja

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

## Prihodnost

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

## Zakaj je to pomembno

GIL je ena od najbolj pomembnih — in najbolj napačno razumljenih — lastnosti Pythona.

Razlaga *zakaj* uporaba niti za CPU-intenzivno delo ne daje pospešitve (pogosta napaka) in *zakaj* je pravilo orodje sočasnosti odvisno od delovne obremenitve: **threading/asyncio za I/O-bound** (kjer je GIL izpuščen med čakanjem) in **multiprocessing za CPU-bound** (ločeni procesi za pravo vzporednost).

Nerazumevanje GIL-a vodi do neučinkovite kode sočasnosti, ki se ne skalira.

Znanje o njem — in o odločitvi I/O-vs-CPU, ki jo vodi — je bistveno za pisanje sočasnega Pythona, ki dejansko deluje.