GIL คืออะไรและมันส่งผลกระทบต่อ concurrency อย่างไร?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) คือ mutex ใน CPython (การใช้งานมาตรฐานของ Python) ที่อนุญาตให้ **เพียงหนึ่ง thread เท่านั้นสามารถเรียกใช้ Python bytecode ในแต่ละครั้ง**. ซึ่งหมายความว่า Python threads ไม่สามารถรันรหัส Python ในแบบขนานที่แท้จริงบนแกน CPU หลายตัวได้ — ซึ่งเป็นพิจารณาที่สำคัญสำหรับ concurrency

## ความหมายของ GIL ในทางปฏิบัติ

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

## ความแตกต่างหลัก: 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
```

ความแตกต่างที่สำคัญ: GIL **ถูกปล่อยออกมาในระหว่าง I/O** (เครือข่าย ไฟล์ sleep) และภายในส่วนขยาย C จำนวนมาก ดังนั้น threads *จึงช่วยได้* สำหรับงาน **I/O-bound** (การรอหลายครั้งทับซ้อนกัน) แต่ *ไม่ช่วย* สำหรับงาน **CPU-bound** (GIL ทำให้การคำนวณต่อเนื่อง)

## การหลีกเลี่ยง GIL สำหรับงาน 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
```

สำหรับ CPU-bound parallelism ให้ใช้ **`multiprocessing`** (กระบวนการแยกต่างหากข้ามไป GIL เดียว) หรือไลบรารี (NumPy เป็นต้น) ที่มีงานหนักทำงานใน C โดยมี GIL ถูกปล่อยออกมา

## คู่มือการตัดสินใจ

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

## อนาคต

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

## เหตุใดจึงมีความสำคัญ

GIL เป็นหนึ่งในลักษณะที่สำคัญที่สุด — และยังเข้าใจผิดมากที่สุด — ของ Python

มันอธิบายว่า*เหตุใด*การใช้ threads สำหรับงานที่ใช้ CPU มากจึงไม่ได้ความเร็ว (ข้อผิดพลาดทั่วไป) และ*เหตุใด*เครื่องมือ concurrency ที่ถูกต้องขึ้นอยู่กับปริมาณงาน: **threading/asyncio สำหรับ I/O-bound** (ซึ่ง GIL ถูกปล่อยออกมาระหว่างการรอ) และ **multiprocessing สำหรับ CPU-bound** (กระบวนการแยกต่างหากสำหรับ parallelism ที่แท้จริง)

การเข้าใจผิดเกี่ยวกับ GIL นำไปสู่โค้ด concurrency ที่ไม่มีประสิทธิภาพซึ่งไม่ปรับขนาด

การรู้เรื่องนี้ — และการตัดสินใจ I/O-vs-CPU ที่มันขับเคลื่อน — เป็นสิ่งจำเป็นสำหรับการเขียน concurrent Python ที่มีประสิทธิภาพจริง