Thread, process và GIL trong Python: concurrent.futures
Chạy song song đúng cách: tác vụ I/O và CPU, ThreadPoolExecutor, ProcessPoolExecutor, Lock, GIL và bản Python free-threaded.
Học xong bài này, bạn sẽ
- Phân biệt tác vụ chờ I/O và tác vụ nặng CPU
- Dùng ThreadPoolExecutor, ProcessPoolExecutor
- Hiểu GIL và bản Python free-threaded
Nên học trước: Đo và tối ưu hiệu năng
Nội dung bài viết
Tải 100 file mà tải lần lượt từng cái, chương trình dành 99% thời gian để chờ mạng. Tính toán nặng trên máy 8 nhân mà chỉ dùng 1 nhân, 7 nhân còn lại ngồi chơi. Chạy đồng thời giải quyết cả hai, nhưng mỗi loại việc cần một công cụ khác nhau. Bài này giải thích sự khác biệt đó, cơ chế GIL của Python, bản Python không GIL (free-threaded), và cách dùng concurrent.futures an toàn.
1. Hai loại việc: chờ I/O và nặng CPU
| Loại | Ví dụ | Thời gian đi đâu | Công cụ |
|---|---|---|---|
| I/O-bound | Gọi API, tải web, truy vấn CSDL, đọc ghi file | Chờ mạng, chờ đĩa | Thread, asyncio (bài sau) |
| CPU-bound | Tính toán số, xử lý ảnh, nén dữ liệu | CPU tính liên tục | Process (hoặc thread trên bản free-threaded) |
Xác định đúng loại trước khi chọn công cụ: dùng profiler (bài trước) hoặc quan sát CPU khi chạy. Chương trình chạy chậm mà CPU gần như rảnh là đang chờ I/O.
2. ThreadPoolExecutor cho việc chờ I/O
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
def tai(url: str) -> str:
time.sleep(0.5) # giả lập chờ mạng 0,5 giây
return f"{url}: xong"
urls = [f"https://vi-du.vn/trang/{i}" for i in range(10)]
t = time.perf_counter()
ket_qua = [tai(u) for u in urls]
print(f"Tuần tự: {time.perf_counter() - t:.1f} s")
t = time.perf_counter()
with ThreadPoolExecutor(max_workers=10) as pool:
ket_qua = list(pool.map(tai, urls)) # giữ đúng thứ tự đầu vào
print(f"10 luồng: {time.perf_counter() - t:.1f} s, {len(ket_qua)} kết quả")
with ThreadPoolExecutor(max_workers=5) as pool:
tuong_lai = {pool.submit(tai, u): u for u in urls[:3]}
for f in as_completed(tuong_lai): # lấy kết quả theo thứ tự XONG TRƯỚC
print(f.result()) # kết quả thay đổi mỗi lần chạy
Tuần tự: 5.0 s
10 luồng: 0.5 s, 10 kết quả
https://vi-du.vn/trang/1: xong
https://vi-du.vn/trang/0: xong
https://vi-du.vn/trang/2: xong
ThreadPoolExecutorquản lý một nhóm luồng;withbảo đảm chờ mọi việc xong rồi mới đi tiếp.pool.map(ham, ds): giốngmap, trả kết quả theo thứ tự đầu vào.pool.submit(ham, ...)trả về mộtFuture(lời hứa có kết quả sau);as_completedlấy theo thứ tự xong trước.f.result()ném lại ngoại lệ nếu hàm bị lỗi, nên bọctry/exceptở đó.- Khi một luồng chờ (sleep, mạng, đĩa), các luồng khác chạy. 10 việc chờ 0,5 giây chạy song song chỉ mất 0,5 giây.
Với gọi API thật, thay thân hàm tai bằng requests.get(url, timeout=10), dùng mỗi luồng một Session hoặc gọi lẻ. Đừng mở hàng trăm luồng cùng lúc vào một máy chủ: giới hạn max_workers hợp lý (5–20) để không bị chặn vì gọi quá nhiều.
3. Race condition và Lock
Luồng dùng chung bộ nhớ: tiện, nhưng nguy hiểm khi nhiều luồng cùng sửa một dữ liệu.
import threading
import time
so_du = 100
def rut(so_tien: int) -> None:
global so_du
if so_du >= so_tien: # kiểm tra...
time.sleep(0.01) # ...thao tác chậm, ví dụ gọi CSDL...
so_du -= so_tien # ...rồi mới trừ: luồng khác đã chen vào giữa
luong = [threading.Thread(target=rut, args=(80,)) for _ in range(2)]
for t in luong:
t.start()
for t in luong:
t.join()
print("Số dư không có khóa:", so_du)
so_du = 100
khoa = threading.Lock()
def rut_an_toan(so_tien: int) -> None:
global so_du
with khoa: # chỉ một luồng được ở trong khối này
if so_du >= so_tien:
time.sleep(0.01)
so_du -= so_tien
luong = [threading.Thread(target=rut_an_toan, args=(80,)) for _ in range(2)]
for t in luong:
t.start()
for t in luong:
t.join()
print("Số dư có khóa:", so_du)
Số dư không có khóa: -60
Số dư có khóa: 20
Cả hai luồng đều kiểm tra thấy đủ 100 ≥ 80 trước khi luồng kia kịp trừ, nên rút tổng 160 từ tài khoản 100. Lỗi kiểu này gọi là race condition: kết quả phụ thuộc thứ tự chạy của các luồng, có thể chỉ xuất hiện một lần trong nghìn lần, cực khó tái hiện. threading.Lock dùng với with bảo đảm đoạn "kiểm tra rồi sửa" chạy trọn vẹn trong một luồng.
pool.map hoặc Future, rồi gộp ở luồng chính, như mục 2. Không có biến dùng chung thì không có race condition. Cần trao đổi liên tục giữa các luồng thì dùng queue.Queue, vốn đã an toàn khi dùng từ nhiều luồng.4. GIL và việc nặng CPU
CPython (bản Python chuẩn) có GIL (Global Interpreter Lock): tại mỗi thời điểm chỉ một luồng được chạy mã Python. Luồng nhả GIL khi chờ I/O (nên mục 2 chạy song song tốt), nhưng với việc tính toán thuần Python, nhiều luồng chỉ thay nhau chạy trên một nhân. Muốn dùng nhiều nhân, dùng nhiều tiến trình: mỗi tiến trình là một trình thông dịch riêng với GIL riêng.
import os
import sys
import time
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
def dem_nguyen_to(bat_dau: int, ket_thuc: int) -> int:
"""Đếm số nguyên tố trong [bat_dau, ket_thuc) bằng cách thử chia: cố tình tốn CPU."""
dem = 0
for n in range(max(bat_dau, 2), ket_thuc):
if all(n % d for d in range(2, int(n**0.5) + 1)):
dem += 1
return dem
def chia_doan(n: int, so_doan: int) -> list[tuple[int, int]]:
buoc = n // so_doan
return [(i * buoc, n if i == so_doan - 1 else (i + 1) * buoc) for i in range(so_doan)]
if __name__ == "__main__": # bắt buộc với ProcessPoolExecutor trên Windows, macOS
N = 2_000_000
doan = chia_doan(N, 4)
gil = sys._is_gil_enabled() if hasattr(sys, "_is_gil_enabled") else True
print(f"Python {sys.version_info.major}.{sys.version_info.minor}, GIL bật: {gil}, CPU: {os.cpu_count()}")
t = time.perf_counter()
kq = dem_nguyen_to(0, N)
print(f"Tuần tự: {kq} số nguyên tố, {time.perf_counter() - t:.1f} s") # kết quả thay đổi theo máy
for ten, Pool in (("4 luồng", ThreadPoolExecutor), ("4 tiến trình", ProcessPoolExecutor)):
t = time.perf_counter()
with Pool(max_workers=4) as pool:
kq = sum(pool.map(dem_nguyen_to, *zip(*doan)))
print(f"{ten:<15} {kq} số nguyên tố, {time.perf_counter() - t:.1f} s")
Kết quả thật trên một máy 8 nhân, với Python 3.14 bản thường và bản free-threaded (mục 5):
| Cách chạy | Python 3.14 (có GIL) | Python 3.14t (không GIL) |
|---|---|---|
| Tuần tự | 9,2 s | 11,7 s |
| 4 luồng | 9,3 s | 4,0 s |
| 4 tiến trình | 3,7 s | 4,7 s |
- Bản có GIL: 4 luồng không nhanh hơn chạy tuần tự; 4 tiến trình nhanh gấp khoảng 2,5 lần.
- Vì sao không gấp 4? Đoạn cuối chứa số lớn nhất, thử chia lâu nhất, nên một tiến trình phải làm lâu hơn ba tiến trình kia. Chia nhỏ thành 32 đoạn cho 4 tiến trình thay nhau nhận, thời gian còn 3,0 giây (bài tập 2).
if __name__ == "__main__":là bắt buộc với tiến trình trên Windows và macOS: tiến trình con import lại file của bạn, thiếu khối này thì mỗi tiến trình con lại tạo thêm tiến trình con.- Dữ liệu gửi qua lại giữa các tiến trình phải được tuần tự hóa (pickle) nên có chi phí; hàm chạy trong tiến trình phải định nghĩa ở cấp module (không dùng lambda). Chia việc thành phần đủ lớn để chi phí đó không đáng kể.
5. Python free-threaded: bản không có GIL
Từ Python 3.13 có thêm bản dựng free-threaded (tên chương trình có hậu tố t, ví dụ python3.14t) tắt GIL, cho phép các luồng chạy song song thật trên nhiều nhân. Cài bằng uv python install 3.14t hoặc trên Windows py install 3.14t. Kiểm tra bằng sys._is_gil_enabled() hoặc python -VV (hiện chữ "free-threading build").
Bảng ở mục 4 cho thấy cả ưu và nhược điểm: 4 luồng chạy nhanh gần gấp 3 nhờ không còn GIL, nhưng chạy tuần tự chậm hơn bản thường. Tài liệu chính thức ghi nhận chi phí đơn luồng trung bình khoảng 1–8% trên bộ đo pyperformance, tùy nền tảng; với vòng lặp tính toán thuần như ví dụ này, chênh lệch có thể lớn hơn. Ngoài ra, một số thư viện viết bằng C chưa hỗ trợ sẽ tự bật lại GIL khi được import, và bộ nhớ dùng nhiều hơn. Bản có GIL vẫn là mặc định; dùng bản free-threaded khi bạn đã đo và thấy lợi, và mọi thư viện cần dùng đều đã hỗ trợ.
6. Chọn công cụ nào?
| Tình huống | Chọn |
|---|---|
| Gọi vài chục API, tải file, truy vấn CSDL đồng thời | ThreadPoolExecutor |
| Hàng nghìn kết nối mạng đồng thời, máy chủ web | asyncio (bài sau) |
| Tính toán nặng bằng Python thuần, chia được thành phần độc lập | ProcessPoolExecutor |
| Tính toán trên mảng số lớn | NumPy, pandas (đã chạy bằng C, nhanh hơn mọi cách chia luồng bằng Python) |
Tóm tắt
- I/O-bound: thread hoặc asyncio; CPU-bound: process, hoặc thread trên bản free-threaded.
concurrent.futures:ThreadPoolExecutor,ProcessPoolExecutor,map,submit,as_completed.- Dữ liệu dùng chung giữa các luồng cần
Lock; tốt hơn là trả kết quả thay vì sửa biến chung. - GIL chỉ cho một luồng chạy mã Python tại một thời điểm; process cần
if __name__ == "__main__".
Bài tập
Bài 1. Kiểm tra nhiều trang web đồng thời
Viết hàm kiểm tra danh sách URL trả về mã trạng thái nào, chạy tuần tự rồi chạy bằng ThreadPoolExecutor 8 luồng, so sánh thời gian. URL lỗi (mất mạng, hết thời gian chờ) ghi là "lỗi" thay vì làm dừng chương trình.
Xem đáp án
# (minh họa) cần mạng; thời gian phụ thuộc đường truyền
import time
from concurrent.futures import ThreadPoolExecutor
import requests
URLS = ["https://www.python.org", "https://docs.python.org/3/", "https://pypi.org",
"https://fastapi.tiangolo.com", "https://docs.astral.sh/uv/", "https://httpbin.org/status/404",
"https://khong-ton-tai.vi-du.invalid", "https://github.com"]
def kiem_tra(url: str) -> tuple[str, str]:
try:
return url, str(requests.get(url, timeout=10).status_code)
except requests.RequestException:
return url, "lỗi"
for ten, chay in [("Tuần tự", lambda: [kiem_tra(u) for u in URLS]),
("8 luồng", lambda: list(ThreadPoolExecutor(8).map(kiem_tra, URLS)))]:
t = time.perf_counter()
ket_qua = chay()
print(f"{ten}: {time.perf_counter() - t:.1f} s", dict(ket_qua)["https://httpbin.org/status/404"])
Tuần tự: 2.1 s 404
8 luồng: 0.8 s 404
Thời gian 8 luồng xấp xỉ thời gian của trang chậm nhất, thay vì tổng thời gian mọi trang. Lỗi được bắt bên trong hàm chạy ở luồng, nên một URL hỏng không ảnh hưởng các URL khác. Tên miền .invalid được dành riêng để không bao giờ tồn tại, tiện cho thử nghiệm lỗi.
Bài 2. Cân bằng tải khi chia việc
Chạy chương trình ở mục 4 với 4 đoạn, rồi với 32 đoạn (vẫn 4 tiến trình). Giải thích vì sao chia nhỏ hơn lại nhanh hơn.
Xem đáp án
Đổi doan = chia_doan(N, 4) thành chia_doan(N, 32). Trên máy thử nghiệm, 4 tiến trình giảm từ 3,7 giây xuống 3,0 giây. Với 4 đoạn, đoạn cuối (1.500.000 đến 2.000.000) tốn nhiều thời gian nhất vì số lớn cần thử nhiều ước hơn; ba tiến trình xong sớm phải ngồi chờ. Với 32 đoạn nhỏ, tiến trình nào xong trước thì nhận đoạn kế tiếp, công việc được chia đều hơn. Chia quá nhỏ (hàng nghìn đoạn) lại chậm vì chi phí gửi nhận dữ liệu giữa các tiến trình; pool.map có tham số chunksize để điều chỉnh việc này.
Nguồn tham khảo: concurrent.futures; threading; Python support for free threading; PEP 703: Making the GIL Optional.
Bài tập thực hành
- Tải đồng thời 20 trang web bằng ThreadPoolExecutor, so thời gian với tải tuần tự.
- Tính số nguyên tố dưới 2.000.000 chia 4 đoạn bằng ProcessPoolExecutor, so với chạy một tiến trình.
Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.


