Apa iku GIL lan piye cara e ngrusak concurrency?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) minangka mutex ing CPython (implementasi Python standar) sing ngidini mung siji thread kanggo execute Python bytecode ing wektu sing sama. Iki tegese thread Python ora bisa run Python code ing paralel sejati ing macem-macem CPU cores — pertimbangan utama kanggo concurrency.

## Apa tegese GIL ing praktik

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

## Beda krusial: 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
```

Tasbih sing penting: GIL **dirilis suwene I/O** (jaringan, file, sleep) lan nang jero macem-macem C extensions. Dadi threads *bisa* tulungan kanggo **I/O-bound** work (macem-macem nunggu sumpah), nanging *ora* kanggo **CPU-bound** work (GIL serialisasi computation).

## Ngobol GIL kanggo CPU-bound work

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

Kanggo parallelism CPU-bound, gunakake **`multiprocessing`** (proseso kapisah ngoboli GIL tunggal), utawa pustaka (NumPy, dll.) sing karya abot-abutan bura ing C karo GIL dirilis.

## Pandhuan keputusan

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

## Masa depan

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

## Mengapa iku penting

GIL minangka salah siji saka Python paling penting — lan paling salah mengerti — karekteristik.

Ikalan nuduhake *mengapa* nggunakake threads kanggo CPU-heavy work ora menehi speedup (kesalahan umum), lan *mengapa* alat concurrency sing bener gumantung ing workload: **threading/asyncio kanggo I/O-bound** (ngendi GIL dirilis suwene nunggu) lan **multiprocessing kanggo CPU-bound** (proseso kapisah kanggo parallelism sejati).

Salah mengerti GIL nyebabake kode concurrency sing ora efektif sing ora scale.

Mengerti e — lan keputusan I/O-vs-CPU sing didrive — penting kanggo nulis Python concurrent sing bener-bener perform.