⭐ Python Developer · Chặng 10Bài 2/6Bài học~75 phút

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.

Thread, process và GIL trong Python: concurrent.futures

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
  1. 1. Hai loại việc: chờ I/O và nặng CPU
  2. 2. ThreadPoolExecutor cho việc chờ I/O
  3. 3. Race condition và Lock
  4. 4. GIL và việc nặng CPU
  5. 5. Python free-threaded: bản không có GIL
  6. 6. Chọn công cụ nào?
  7. Tóm tắt
  8. Bài tập

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ạiVí dụThời gian đi đâuCông cụ
I/O-boundGọi API, tải web, truy vấn CSDL, đọc ghi fileChờ mạng, chờ đĩaThread, asyncio (bài sau)
CPU-boundTính toán số, xử lý ảnh, nén dữ liệuCPU tính liên tụcProcess (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
  • ThreadPoolExecutor quản lý một nhóm luồng; with bảo đảm chờ mọi việc xong rồi mới đi tiếp.
  • pool.map(ham, ds): giống map, trả kết quả theo thứ tự đầu vào.
  • pool.submit(ham, ...) trả về một Future (lời hứa có kết quả sau); as_completed lấ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ọc try/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.

Cách an toàn nhất: không chia sẻ trạng tháiThiết kế để mỗi luồng nhận dữ liệu riêng và trả kết quả qua 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ạyPython 3.14 (có GIL)Python 3.14t (không GIL)
Tuần tự9,2 s11,7 s
4 luồng9,3 s4,0 s
4 tiến trình3,7 s4,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ốngChọn
Gọi vài chục API, tải file, truy vấn CSDL đồng thờiThreadPoolExecutor
Hàng nghìn kết nối mạng đồng thời, máy chủ webasyncio (bài sau)
Tính toán nặng bằng Python thuần, chia được thành phần độc lậpProcessPoolExecutor
Tính toán trên mảng số lớnNumPy, 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

  1. Tải đồng thời 20 trang web bằng ThreadPoolExecutor, so thời gian với tải tuần tự.
  2. 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.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.