Co to jest GIL i jak wpływa on na współbieżność?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) to mutex w CPython (standardowej implementacji Pythona), który pozwala **tylko jednemu wątkowi na raz wykonywać bajtkod Pythona**. Oznacza to, że wątki Pythona nie mogą uruchamiać kodu Pythona w prawdziwym równoległości na wielu rdzeniach CPU — ważne rozważanie przy współbieżności.

## Dlaczego to ważne

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

## Kluczowe rozróżnienie: 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
```

Decydujące niuanse: GIL jest **zwolniony podczas I/O** (sieć, plik, sleep) i wewnątrz wielu rozszerzeń C. Zatem wątki *faktycznie pomagają* w pracy **I/O-bound** (wiele oczekiwań się nakłada), ale *nie* w pracy **CPU-bound** (GIL serializuje obliczenia).

## Obejścia GIL-a dla pracy 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
```

Do paralelizmu CPU-bound użyj **`multiprocessing`** (oddzielne procesy omijają pojedynczy GIL) lub bibliotek (NumPy itp.) których ciężka praca wykonywana jest w C ze zwolnionym GIL.

## Przewodnik decyzji

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

## Przyszłość

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

## Dlaczego to ważne

GIL to jedna z najważniejszych — i najczęściej niezrozumianych — cech Pythona.

Wyjaśnia *dlaczego* używanie wątków do pracy CPU-intensywnej nie daje przyspieszenia (częsty błąd) i *dlaczego* właściwe narzędzie współbieżności zależy od obciążenia: **threading/asyncio dla I/O-bound** (gdzie GIL jest zwolniony podczas oczekiwania) i **multiprocessing dla CPU-bound** (oddzielne procesy dla prawdziwej paralelności).

Niezrozumienie GIL-a prowadzi do nieefektywnego kodu współbieżności, który się nie skaluje.

Znajomość go — i decyzji I/O-vs-CPU, którą napędza — jest niezbędna do pisania współbieżnego Pythona, który faktycznie działa.