Mi a GIL és hogyan befolyásolja az egyidejűséget?

Question

Accepted Answer

A **GIL** (Global Interpreter Lock) a CPython-ban (a szabványos Python implementáció) egy mutex, amely csak **egyetlen szálnak engedélyezi a Python bytecode egyidejű végrehajtását**. Ez azt jelenti, hogy a Python szálak nem tudnak igazi párhuzamos módon Python kódot futtatni több CPU magot felhasználva — fontos megfontolandó szempont az egyidejűséghez.

## Mit jelent a GIL a gyakorlatban

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

## A legfontosabb különbség: CPU-kötött vs I/O-kötött

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

A lényeges árnyalat: a GIL **I/O alatt felszabadul** (hálózat, fájl, alvás) és sok C bővítmény belsejében. Így a szálak **segítségére vannak az I/O-kötött** munkához (több várakozás átfedésben), de **nem az CPU-kötött** munkához (a GIL szerializálja a számítást).

## A GIL megkerülése CPU-kötött munka esetén

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

CPU-kötött párhuzamossághoz használjon **`multiprocessing`** (külön folyamatok megkerülik az egyetlen GIL-t), vagy könyvtárakat (NumPy, stb.), amelyek nehéz munkája C-ben fut a felszabadított GIL-lel.

## A döntési útmutató

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

## A jövő

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

## Miért fontos

A GIL a Python egyik legfontosabb — és leginkább félreértett — jellemzője.

Magyarázza, *miért* nem ad gyorsulást a szálak CPU-intenzív munka esetén (gyakori hiba), és *miért* függ a megfelelő egyidejűségi eszköz a terheléstől: **szálkezelés/asyncio az I/O-kötött** (ahol a GIL felszabadul a várakozás alatt) és **multiprocessing a CPU-kötött** (külön folyamatok az igazi párhuzamossághoz) munkához.

A GIL félreértése nem hatékony, nem skálázható párhuzamos kódhoz vezet.

Az ismerete — és az általa hajtott I/O vs CPU döntés — alapvető a ténylegesen teljesítményes párhuzamos Python kód írásához.