Apa itu GIL dan bagaimana pengaruhnya terhadap kebersamaan?

Question

IT Interview Practice · Accepted Answer

**GIL** (Global Interpreter Lock) adalah mutex dalam CPython (implementasi Python standar) yang memungkinkan hanya **satu thread untuk menjalankan Python bytecode pada satu waktu**. Ini berarti thread Python tidak dapat menjalankan kode Python dalam kebersamaan sejati di beberapa inti CPU — pertimbangan penting untuk kebersamaan.

## Apa yang GIL berarti dalam 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.
```

## Perbedaan kunci: 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
```

Nuansa penting: GIL **dirilis selama I/O** (jaringan, file, sleep) dan di dalam banyak ekstensi C. Jadi thread *membantu* untuk pekerjaan **I/O-bound** (beberapa tunggu tumpang tindih), tetapi *tidak* untuk pekerjaan **CPU-bound** (GIL menserialisasi komputasi).

## Mengerjakan pekerjaan CPU-bound tanpa GIL

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

Untuk kebersamaan CPU-bound, gunakan **`multiprocessing`** (proses terpisah menghindari GIL tunggal), atau pustaka (NumPy, dll.) yang pekerjaan beratnya berjalan di C dengan GIL dirilis.

## Panduan 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 ini penting

GIL adalah salah satu karakteristik Python yang paling penting — dan paling disalahpahami.

Ini menjelaskan *mengapa* menggunakan thread untuk pekerjaan intensif CPU tidak memberikan percepatan (kesalahan umum), dan *mengapa* alat kebersamaan yang tepat tergantung pada beban kerja: **threading/asyncio untuk I/O-bound** (di mana GIL dirilis selama tunggu) dan **multiprocessing untuk CPU-bound** (proses terpisah untuk kebersamaan sejati).

Salah memahami GIL menyebabkan kode kebersamaan yang tidak efektif yang tidak dapat diskalakan.

Mengetahuinya — dan keputusan I/O-vs-CPU yang mendorongnya — sangat penting untuk menulis kode Python kebersamaan yang benar-benar berkinerja.

Apa yang GIL berarti dalam praktik

Perbedaan kunci: CPU-bound vs I/O-bound

Mengerjakan pekerjaan CPU-bound tanpa GIL

Panduan keputusan

Masa depan

Mengapa ini penting

Pertanyaan terkait