Co je GIL a jak ovlivňuje souběžnost?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) je mutex v CPythonu (standardní implementaci Pythonu), který umožňuje, aby **pouze jedno vlákno najednou provádělo Python bytecode**. To znamená, že vlákna v Pythonu nemohou spouštět Python kód v pravé paralelě na více jádrech CPU — jedná se o důležitou skutečnost pro souběžnost.

## Co GIL znamená v praxi

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

## Klíčové rozlišení: CPU-vázané vs I/O-vázané

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

Zásadní nuance: GIL je **uvolněn během I/O** (síť, soubor, sleep) a uvnitř mnoha C rozšíření. Takže vlákna *skutečně* pomáhají pro **I/O-vázanou** práci (více čekání se překrývá), ale *nikoli* pro **CPU-vázanou** práci (GIL serializuje výpočty).

## Obcházení GIL pro CPU-vázanou práci

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

Pro paralelismus vázaný na CPU použijte **`multiprocessing`** (samostatné procesy obcházejí jediný GIL), nebo knihovny (NumPy, atd.), jejichž těžká práce běží v C s uvolněným GIL.

## Průvodce rozhodováním

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

## Budoucnost

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

## Proč to má smysl

GIL je jednou z nejdůležitějších — a zároveň nejméně pochopených — vlastností Pythonu.

Vysvětluje *proč* používání vláken pro CPU-těžkou práci nepřináší zrychlení (běžná chyba), a *proč* správný nástroj souběžnosti závisí na typu úlohy: **threading/asyncio pro I/O-vázanou** (kde je GIL uvolněn během čekání) a **multiprocessing pro CPU-vázanou** (samostatné procesy pro skutečný paralelismus).

Nezpochopení GIL vede k neefektivnímu kódu souběžnosti, který se neškáluje.

Znalost GIL — a rozhodnutí I/O versus CPU, které řídí — je nezbytná pro napsání souběžného Pythonu, který skutečně funguje.