GIL là gì và nó ảnh hưởng đến concurrency như thế nào?

Question

Accepted Answer

**GIL** (Global Interpreter Lock — khóa thông dịch toàn cục) là một mutex trong CPython (bản hiện thực Python tiêu chuẩn) chỉ cho phép **một thread thực thi Python bytecode tại một thời điểm**. Điều này có nghĩa các thread Python không thể chạy code Python song song thực sự trên nhiều lõi CPU — một cân nhắc lớn đối với concurrency.

## GIL có nghĩa gì trong thực tế

```text
Ngay cả với nhiều thread trên một CPU đa lõi:
  Chỉ MỘT thread chạy Python bytecode tại bất kỳ thời điểm nào.
→ Threading KHÔNG mang lại song song hóa cho tác vụ CPU-bound trong CPython.
```

## Sự phân biệt then chốt: CPU-bound vs I/O-bound

```python
import threading

# ❌ công việc CPU-bound với thread — KHÔNG tăng tốc (GIL tuần tự hóa chúng)
def cpu_task():
    sum(i * i for i in range(10_000_000))   # tính toán nặng
# 4 thread làm việc này chạy gần như chậm như 1 (tranh chấp GIL)

# ✅ công việc I/O-bound với thread — lợi ích THỰC SỰ
def io_task():
    response = requests.get(url)   # chờ mạng — GIẢI PHÓNG GIL trong lúc chờ
# trong khi một thread chờ I/O, GIL được giải phóng cho các thread khác → concurrency hoạt động
```

Sắc thái quan trọng: GIL được **giải phóng trong lúc I/O** (mạng, file, sleep) và bên trong nhiều C extension. Vì vậy thread *có* giúp cho công việc **I/O-bound** (nhiều lần chờ chồng lấp), nhưng *không* cho công việc **CPU-bound** (GIL tuần tự hóa việc tính toán).

## Vượt qua GIL cho công việc CPU-bound

```python
from multiprocessing import Pool

# ✅ multiprocessing dùng các TIẾN TRÌNH riêng, mỗi cái có GIL riêng → song song thực sự
with Pool(4) as p:
    results = p.map(cpu_task, data)   # chạy trên 4 lõi thực sự song song
```

Đối với song song hóa CPU-bound, dùng **`multiprocessing`** (các tiến trình riêng né tránh GIL đơn lẻ), hoặc các thư viện (NumPy, v.v.) có công việc nặng chạy trong C với GIL được giải phóng.

## Hướng dẫn quyết định

```text
I/O-bound (mạng, file, DB)       → threading hoặc asyncio (GIL được giải phóng khi I/O)
CPU-bound (tính toán)            → multiprocessing (hoặc thư viện C-extension)
```

## Tương lai

```text
Python 3.13+ giới thiệu một bản build free-threaded (không-GIL) THỬ NGHIỆM,
và công việc tiếp tục giảm tác động của GIL — nhưng nó vẫn là thực tế mặc định.
```

## Tại sao điều này quan trọng

GIL là một trong những đặc điểm quan trọng nhất — và bị hiểu lầm nhiều nhất — của Python.

Nó giải thích *tại sao* dùng thread cho công việc nặng về CPU không mang lại tăng tốc (một sai lầm phổ biến), và *tại sao* công cụ concurrency đúng phụ thuộc vào loại tải: **threading/asyncio cho I/O-bound** (nơi GIL được giải phóng khi chờ) và **multiprocessing cho CPU-bound** (các tiến trình riêng cho song song thực sự).

Hiểu lầm về GIL dẫn đến code concurrency không hiệu quả không mở rộng được.

Biết nó — và quyết định I/O-vs-CPU mà nó dẫn dắt — là thiết yếu để viết Python concurrency thực sự có hiệu năng.