Khi nào bạn chọn threading, multiprocessing, hay asyncio?

Question

Accepted Answer

Python cung cấp ba mô hình concurrency, và chọn đúng phụ thuộc chủ yếu vào việc công việc của bạn là **I/O-bound** hay **CPU-bound** — một quyết định bị định hình mạnh bởi GIL (vốn ngăn các thread chạy code Python song song).

## Ba mô hình

```text
threading        → nhiều thread, MỘT tiến trình. Bị giới hạn bởi GIL với CPU.
multiprocessing  → nhiều TIẾN TRÌNH, mỗi cái có interpreter/GIL riêng → song song thực sự.
asyncio          → một thread, các coroutine hợp tác nhường quyền tại điểm await.
```

## threading — cho concurrency I/O-bound

```python
from concurrent.futures import ThreadPoolExecutor

# ✅ tốt cho I/O — GIL được GIẢI PHÓNG trong lúc chờ I/O, nên các lần chờ chồng lấp
with ThreadPoolExecutor(max_workers=10) as ex:
    results = list(ex.map(download_url, urls))   # nhiều lượt tải đồng thời
```

Thread hoạt động tốt cho các tác vụ I/O-bound (mạng, file, DB) vì GIL được giải phóng trong lúc chờ — nhiều lần chờ tiến hành đồng thời. Chúng **không** tăng tốc công việc CPU-bound.

## multiprocessing — cho song song hóa CPU-bound

```python
from concurrent.futures import ProcessPoolExecutor

# ✅ tốt cho CPU — các tiến trình riêng mỗi cái có GIL riêng → dùng tất cả lõi
with ProcessPoolExecutor(max_workers=4) as ex:
    results = list(ex.map(heavy_computation, data))   # song song thực sự
```

Đối với công việc nặng-CPU (xử lý ảnh, toán học, nghiền dữ liệu), các tiến trình riêng vượt qua GIL đơn lẻ và chạy thực sự song song trên nhiều lõi. Cái giá: chi phí cao hơn (khởi động tiến trình) và dữ liệu phải được **serialize** giữa các tiến trình (không có bộ nhớ chia sẻ theo mặc định).

## asyncio — cho I/O độ đồng thời cao

```python
import asyncio
# ✅ tốt nhất cho NHIỀU thao tác I/O đồng thời (hàng nghìn) — nhẹ nhất
await asyncio.gather(*(fetch(url) for url in urls))
```

asyncio xử lý số lượng khổng lồ các thao tác I/O đồng thời trên một thread, hiệu quả hơn thread (không có chi phí mỗi-thread) — lý tưởng cho server và code mạng độ đồng thời cao.

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

```text
CPU-bound (tính toán)                → multiprocessing
I/O-bound, độ đồng thời vừa phải      → threading (đơn giản, hoạt động với thư viện đồng bộ)
I/O-bound, độ đồng thời CAO           → asyncio (hàng nghìn kết nối, nhưng cần
                                       thư viện tương thích async)
Kết hợp CPU + I/O                     → kết hợp (ví dụ asyncio + một process pool cho CPU)
```

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

Chọn đúng mô hình concurrency là một trong những quyết định hiệu năng Python quan trọng nhất, và làm sai (sai lầm kinh điển: thread cho công việc CPU-bound, điều mà GIL khiến vô dụng) dẫn đến code không mở rộng được.

Logic dẫn dắt bắt nguồn từ GIL: **thread/asyncio cho I/O-bound** (GIL được giải phóng khi chờ — concurrency hoạt động) và **multiprocessing cho CPU-bound** (các GIL riêng cho song song thực sự), với asyncio được ưu tiên khi độ đồng thời rất cao.

Hiểu điểm mạnh, cái giá (chi phí tiến trình/serialize, yêu cầu thư viện của asyncio) của mỗi mô hình, và quyết định I/O-vs-CPU là thiết yếu để viết Python concurrency thực sự mang lại hiệu năng.