Kas yra GIL ir kaip jis veikia lygiagrečumą?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) yra muteksas CPython-uje (standartinis Python runtime), kuris leidžia tik **vienam gijui iš karto vykdyti Python bytecode**. Tai reiškia, kad Python gijos negali vykdyti Python kodo tikrai lygiagrečiai keliuose CPU branduoliuose — svarbios lygiagrečumo aplinkybės.

## Ką GIL reiškia praktikoje

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

## Pagrindinė skirtumai: 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
```

Svarbi niuansas: GIL **atleidžiamas I/O metu** (tinklas, failai, sleep) ir daugelyje C plėtinių. Taigi gijos *padeda* **I/O-bound** darbams (keli laukimai sutampa), bet *ne* **CPU-bound** darbams (GIL serializuoja skaičiavimą).

## Kaip apsieti su GIL CPU-bound darbuose

```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-bound paralelizmui naudokite **`multiprocessing`** (atskiri procesai apsikeičia vienu GIL), arba bibliotekas (NumPy ir kt.), kurių sunkus darbas vykdomas C su GIL atleidžiamu.

## Sprendimo vadovas

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

## Ateitis

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

## Kodėl tai svarbu

GIL yra vienas iš Python labiausiai svarbių — ir dažniausiai nepaguodžiamų — charakteristika.

Jis paaiškina *kodėl* naudojant gijas CPU-sunkiam darbui negauna greitesnio įgyvendinimo (dažna klaida), ir *kodėl* teisingas lygiagrečumo įrankis priklauso nuo darbo krūvio: **threading/asyncio I/O-bound** (kur GIL atleidžiamas laukimo metu) ir **multiprocessing CPU-bound** (atskiri procesai tikram paralelizmui).

GIL nepagalvojimas veda prie neefektyvaus lygiagrečaus kodo, kuris nemastelinasi.

Jo žinojimas — ir I/O-vs-CPU sprendimas, kurį jis varo — būtinas rašant iš tikro veikiantį lygiagretų Python kodą.