Fullstack Python
Trang chủ / Module 3
⚙️ Module 3 / 19 · 5 ngày 📅 Tuần 2 ●●●○ Khó

Python runtime từ bên trong: GIL, free-threading, bộ nhớ, asyncio, đồng thời

CPython chạy code thế nào, GIL là gì và vì sao Python 3.13/3.14 có bản free-threaded, quản lý bộ nhớ và GC, asyncio event loop, chọn đúng giữa async, thread, process cho I/O-bound và CPU-bound, và bẫy chặn event loop.

CPythonGILFree-threadedasynciomultiprocessingMemory
📌 Vì sao module này quan trọng

Câu "Python chậm vì GIL" xuất hiện ở hầu hết phỏng vấn backend Python — và câu trả lời của senior phải chính xác hơn nhiều: GIL ảnh hưởng gì, không ảnh hưởng gì, khi nào dùng async, thread hay process. Trong production, bug nghiêm trọng nhất của FastAPI là gọi hàm đồng bộ chặn event loop làm mọi request treo. Hiểu runtime là thứ cho phép bạn chọn số worker Uvicorn/Gunicorn, thiết kế job nặng và giải thích hiệu năng bằng lý lẽ thay vì cảm tính.

🎯 Mục tiêu học tập

  • Mô tả CPython: bytecode, interpreter, reference counting và cycle GC
  • Giải thích GIL, tác động lên I/O-bound vs CPU-bound, và bản free-threaded (PEP 703/779)
  • Viết code asyncio đúng: task, gather, TaskGroup, timeout, cancellation, semaphore
  • Chọn đúng async / threading / multiprocessing / hàng đợi cho từng loại việc
  • Phát hiện việc chặn event loop và tìm memory leak

CPython, bộ nhớ và GC

  • Mã nguồn → bytecode (dis để xem) → vòng lặp interpreter thực thi. Python 3.11+ có specializing adaptive interpreter (nhanh hơn 10-60% so với 3.10); 3.13+ có JIT thử nghiệm.
  • Reference counting: object hết tham chiếu được giải phóng ngay; cycle GC theo thế hệ thu hồi vòng tham chiếu.
  • Leak thường gặp trong service chạy lâu: cache dict toàn cục không giới hạn (dùng functools.lru_cache(maxsize=...)/cachetools), list tích tụ, closure giữ object lớn, connection không đóng.
  • Công cụ: tracemalloc (so sánh snapshot), memray, objgraph.
import tracemalloc
tracemalloc.start()
snap1 = tracemalloc.take_snapshot()
# ... chạy tải ...
snap2 = tracemalloc.take_snapshot()
for stat in snap2.compare_to(snap1, "lineno")[:10]:
    print(stat)                 # dòng code nào cấp phát bộ nhớ tăng nhiều nhất

GIL và free-threaded Python

GIL (Global Interpreter Lock) chỉ cho một thread thực thi bytecode Python tại một thời điểm trong một tiến trình.

Loại việcẢnh hưởng của GILGiải pháp
I/O-bound (DB, HTTP, file)Ít — GIL được nhả khi chờ I/Oasyncio hoặc thread
CPU-bound thuần PythonLớn — thread không chạy song songmultiprocessing / ProcessPoolExecutor, nhiều worker process, đẩy sang job
CPU-bound trong thư viện C (NumPy, Pillow, polars)Thường nhả GILThread vẫn tận dụng được nhiều core

Free-threaded build: Python 3.13 có bản thử nghiệm bỏ GIL (python3.13t); từ 3.14 bản này được hỗ trợ chính thức (chưa phải mặc định). Thread chạy song song thật trên nhiều core, đổi lại hiệu năng đơn luồng thấp hơn một chút và thư viện C extension phải tương thích. Năm 2026 đa số production vẫn chạy bản có GIL — biết để đánh giá, kiểm tra hệ sinh thái trước khi dùng.

asyncio đúng cách

import asyncio, httpx

async def fetch_all(urls: list[str]) -> list[dict]:
    sem = asyncio.Semaphore(10)                         # giới hạn đồng thời — không bắn 10.000 request cùng lúc
    async with httpx.AsyncClient(timeout=5) as client:  # dùng lại client (connection pool)
        async def one(url: str) -> dict:
            async with sem:
                r = await client.get(url)
                r.raise_for_status()
                return r.json()
        async with asyncio.TaskGroup() as tg:           # 3.11+: lỗi một task → huỷ các task còn lại
            tasks = [tg.create_task(one(u)) for u in urls]
    return [t.result() for t in tasks]

async def with_deadline():
    async with asyncio.timeout(3):                      # 3.11+
        await slow_operation()
  • Coroutine chỉ chạy khi được await hoặc tạo thành task; quên await = không chạy (có cảnh báo "coroutine was never awaited").
  • Cancellation là cơ chế quan trọng: CancelledError phải được để lan truyền, không nuốt; dọn dẹp trong finally.
  • asyncio.gather(..., return_exceptions=True) khi muốn thu kết quả từng phần.

Bẫy số 1: chặn event loop

# ❌ Trong endpoint async: requests, time.sleep, psycopg2, đọc file lớn, tính toán nặng → MỌI request khác chờ
@app.get("/report")
async def report():
    data = requests.get(URL).json()          # chặn!
    return heavy_compute(data)                # chặn!

# ✅ Dùng thư viện async, hoặc đẩy việc đồng bộ ra thread/process
@app.get("/report")
async def report():
    async with httpx.AsyncClient() as c:
        data = (await c.get(URL)).json()
    return await asyncio.to_thread(heavy_compute, data)        # I/O đồng bộ hoặc C extension
    # CPU nặng thuần Python: ProcessPoolExecutor hoặc Celery job

# ✅ Hoặc khai báo endpoint là def thường — FastAPI tự chạy trong threadpool
@app.get("/legacy")
def legacy():
    return requests.get(URL).json()

Phát hiện: PYTHONASYNCIODEBUG=1 / loop.set_debug(True) cảnh báo callback chạy > 100ms; ruff rule ASYNC; đo latency khi có một request nặng song song.

Chọn mô hình đồng thời

Công cụHợp với
asyncioNhiều I/O đồng thời: API gateway, WebSocket, gọi nhiều service, stream LLM
threading / ThreadPoolExecutorI/O với thư viện đồng bộ, C extension nhả GIL
multiprocessing / ProcessPoolExecutorCPU-bound thuần Python trong một máy
Nhiều worker process (Gunicorn/Uvicorn workers)Tận dụng nhiều core cho web server
Hàng đợi (Celery, arq, Dramatiq)Việc lâu, không cần trả kết quả ngay, cần retry (Module 8)

🏋️ Bài tập thực hành

Chứng minh bằng số liệu

(1) Đo thời gian tải 200 URL bằng requests tuần tự, ThreadPoolExecutor, asyncio + httpx với semaphore. (2) Hàm CPU-bound (tính số nguyên tố): so sánh thread, process, và (nếu có) Python 3.14 free-threaded. (3) Tạo endpoint FastAPI async gọi time.sleep(2), dùng k6 chứng minh mọi request khác bị treo; sửa bằng 3 cách. (4) Tạo memory leak bằng cache toàn cục, tìm bằng tracemalloc, sửa bằng LRU có giới hạn. Viết báo cáo ngắn có bảng số liệu.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Giải thích chính xác GIL ảnh hưởng gì và không ảnh hưởng gì
  • Viết asyncio có giới hạn đồng thời, timeout, TaskGroup
  • Không bao giờ chặn event loop trong endpoint async
  • Chọn đúng async/thread/process/queue cho từng loại việc