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

asyncio trong Python: async, await, gather, TaskGroup, httpx

Lập trình bất đồng bộ: event loop, coroutine, await, gather, TaskGroup, Semaphore, timeout và gọi HTTP đồng thời bằng httpx.

asyncio trong Python: async, await, gather, TaskGroup, httpx

Học xong bài này, bạn sẽ

  • Hiểu event loop, coroutine, await
  • Chạy nhiều tác vụ đồng thời bằng gather, TaskGroup, giới hạn bằng Semaphore
  • Gọi HTTP bất đồng bộ bằng httpx

Nên học trước: Đồng thời với thread, process và GIL

Nội dung bài viết
  1. 1. Coroutine, await và event loop
  2. 2. Quy tắc quan trọng nhất: đừng chặn event loop
  3. 3. TaskGroup, timeout và Semaphore
  4. 4. Gọi HTTP bất đồng bộ với httpx
  5. Tóm tắt
  6. Bài tập

Thread giải quyết tốt việc chờ I/O với vài chục tác vụ. Nhưng một máy chủ web phải giữ hàng nghìn kết nối cùng lúc, mỗi kết nối phần lớn thời gian chỉ ngồi chờ; một luồng cho mỗi kết nối thì quá tốn tài nguyên. asyncio chạy hàng nghìn tác vụ chờ đồng thời trong một luồng duy nhất bằng cú pháp async/await. Đây là nền tảng của FastAPI, httpx, và phần lớn thư viện mạng hiện đại.

1. Coroutine, await và event loop

import asyncio
import time


async def nau(mon: str, phut: float) -> str:      # async def: định nghĩa coroutine
    print(f"Bắt đầu {mon}")
    await asyncio.sleep(phut)                     # await: "chờ ở đây, trong lúc đó làm việc khác"
    print(f"Xong {mon}")
    return mon


async def main() -> None:
    t = time.perf_counter()
    ket_qua = await asyncio.gather(nau("cơm", 0.3), nau("canh", 0.2), nau("cá", 0.1))
    print(ket_qua, f"{time.perf_counter() - t:.1f} s")


asyncio.run(main())                               # tạo event loop và chạy coroutine chính
Bắt đầu cơm
Bắt đầu canh
Bắt đầu cá
Xong cá
Xong canh
Xong cơm
['cơm', 'canh', 'cá'] 0.3 s
  • async def định nghĩa một coroutine: gọi nau("cơm", 0.3) chưa chạy gì, chỉ tạo đối tượng coroutine.
  • await chạy coroutine và tạm dừng hàm hiện tại cho đến khi có kết quả. Trong lúc tạm dừng, event loop (vòng lặp sự kiện) chuyển sang chạy coroutine khác đang sẵn sàng.
  • asyncio.gather chạy nhiều coroutine đồng thời và trả kết quả theo đúng thứ tự truyền vào. Ba món nấu cùng lúc: tổng 0,3 giây (món lâu nhất) thay vì 0,6 giây.
  • asyncio.run(main()) là điểm vào duy nhất, gọi một lần ở cấp cao nhất của chương trình.

Hình dung một đầu bếp (một luồng) nấu ba món: đặt nồi cơm lên bếp (await) rồi quay sang nấu canh, không đứng nhìn nồi cơm. Chỉ khi ba món đều đang chờ chín, đầu bếp mới rảnh.

2. Quy tắc quan trọng nhất: đừng chặn event loop

import asyncio
import time


async def sai() -> None:
    time.sleep(0.2)            # hàm đồng bộ: CHẶN cả event loop, không ai chạy được


async def dung() -> None:
    await asyncio.sleep(0.2)   # nhường event loop trong lúc chờ


async def do(ham) -> float:
    t = time.perf_counter()
    await asyncio.gather(*(ham() for _ in range(5)))
    return time.perf_counter() - t


print(f"time.sleep:    {asyncio.run(do(sai)):.1f} s")
print(f"asyncio.sleep: {asyncio.run(do(dung)):.1f} s")
time.sleep:    1.0 s
asyncio.sleep: 0.2 s

asyncio là hợp tác: coroutine chỉ nhường quyền tại các điểm await. Gọi hàm đồng bộ chậm (time.sleep, requests.get, truy vấn CSDL đồng bộ, tính toán nặng) bên trong async def sẽ đóng băng mọi tác vụ khác. Vì vậy trong code bất đồng bộ phải dùng thư viện bất đồng bộ: httpx.AsyncClient thay cho requests, asyncio.sleep thay cho time.sleep. Bắt buộc phải gọi hàm đồng bộ thì đẩy nó sang luồng: await asyncio.to_thread(ham_dong_bo, ...).

Đây cũng là lý do ở chặng 9 các endpoint dùng def thường: SQLAlchemy đồng bộ, và FastAPI tự chạy endpoint def trong nhóm luồng riêng. Viết async def mà gọi Session đồng bộ bên trong sẽ chặn cả máy chủ.

3. TaskGroup, timeout và Semaphore

import asyncio


async def lay(i: int, gioi_han: asyncio.Semaphore) -> str:
    async with gioi_han:                           # tối đa N tác vụ cùng lúc vào đây
        await asyncio.sleep(0.1 if i != 3 else 5)  # tác vụ số 3 treo lâu
        return f"việc {i}"


async def lay_co_han(i: int, gioi_han: asyncio.Semaphore) -> str:
    try:
        async with asyncio.timeout(0.5):           # quá 0,5 s thì hủy (Python 3.11+)
            return await lay(i, gioi_han)
    except TimeoutError:
        return f"việc {i}: quá thời gian"


async def main() -> None:
    gioi_han = asyncio.Semaphore(2)
    async with asyncio.TaskGroup() as tg:          # Python 3.11+
        cac_viec = [tg.create_task(lay_co_han(i, gioi_han)) for i in range(5)]
    print([v.result() for v in cac_viec])


asyncio.run(main())
['việc 0', 'việc 1', 'việc 2', 'việc 3: quá thời gian', 'việc 4']
  • asyncio.TaskGroup (Python 3.11+) là cách hiện đại để chạy nhiều tác vụ: ra khỏi khối async with thì mọi tác vụ đã xong; nếu một tác vụ ném lỗi, các tác vụ còn lại bị hủy và lỗi được báo ra (dạng ExceptionGroup). gather vẫn dùng tốt cho trường hợp đơn giản.
  • asyncio.timeout(giay) hủy khối lệnh nếu quá hạn và ném TimeoutError. Luôn đặt giới hạn thời gian khi gọi mạng.
  • asyncio.Semaphore(2) giới hạn số tác vụ chạy đồng thời trong khối async with: tránh mở 10.000 kết nối cùng lúc tới một máy chủ.

4. Gọi HTTP bất đồng bộ với httpx

Kiểm tra 10 URL, tối đa 3 kết nối cùng lúc, mỗi URL tối đa 3 giây, URL lỗi không làm hỏng URL khác. httpx đã được cài kèm fastapi[standard], hoặc uv add httpx.

# (minh họa) cần mạng; thời gian phụ thuộc đường truyền
import asyncio
import time

import httpx

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://httpbin.org/delay/5", "https://github.com",
        "https://www.wikipedia.org"]


async def kiem_tra(client: httpx.AsyncClient, gioi_han: asyncio.Semaphore, url: str) -> tuple[str, str]:
    async with gioi_han:
        try:
            async with asyncio.timeout(3):
                r = await client.get(url, follow_redirects=True)
            return url, str(r.status_code)
        except TimeoutError:
            return url, "quá thời gian"
        except httpx.HTTPError as e:
            return url, f"lỗi {type(e).__name__}"


async def main() -> None:
    gioi_han = asyncio.Semaphore(3)
    async with httpx.AsyncClient(headers={"User-Agent": "hoc-python/1.0"}) as client:
        async with asyncio.TaskGroup() as tg:
            viec = [tg.create_task(kiem_tra(client, gioi_han, u)) for u in URLS]
    for v in viec:
        url, kq = v.result()
        print(f"{kq:<16} {url}")


t = time.perf_counter()
asyncio.run(main())
print(f"{time.perf_counter() - t:.1f} s")
200              https://www.python.org
200              https://docs.python.org/3/
200              https://pypi.org
200              https://fastapi.tiangolo.com
200              https://docs.astral.sh/uv/
404              https://httpbin.org/status/404
lỗi ConnectError https://khong-ton-tai.vi-du.invalid
quá thời gian    https://httpbin.org/delay/5
200              https://github.com
200              https://www.wikipedia.org
3.4 s

Một AsyncClient dùng chung cho mọi request (giữ và tái sử dụng kết nối, như Session của requests). Lỗi được bắt bên trong từng tác vụ nên TaskGroup không bị hủy giữa chừng. httpbin.org/delay/5 trả lời sau 5 giây, bị cắt ở giây thứ 3. Tổng thời gian khoảng 3,4 giây cho 10 URL, chủ yếu do URL chậm nhất.

Chọn thread hay asyncio?Script tự động hóa gọi vài chục API bằng requests: ThreadPoolExecutor đơn giản hơn, không phải đổi thư viện. Ứng dụng mạng có hàng trăm, hàng nghìn kết nối đồng thời, hoặc đã dùng framework bất đồng bộ (FastAPI với thư viện async, bot chat, websocket): asyncio. Đừng trộn lẫn tùy tiện; nhất quán trong một chương trình sẽ dễ bảo trì hơn.

Tóm tắt

  • async def tạo coroutine; await chờ và nhường event loop; asyncio.run(main()) là điểm vào.
  • Không gọi hàm đồng bộ chậm trong async def; dùng thư viện async hoặc asyncio.to_thread.
  • gather, TaskGroup chạy đồng thời; asyncio.timeout giới hạn thời gian; Semaphore giới hạn số tác vụ.
  • httpx.AsyncClient dùng chung cho các request bất đồng bộ.

Bài tập

Bài 1. Kiểm tra URL còn sống

Dùng chương trình ở mục 4 với danh sách 10 URL của riêng bạn, giới hạn 3 kết nối. Đo thời gian khi đổi giới hạn thành 1 và 10, giải thích kết quả.

Xem gợi ý

Với Semaphore(1), mọi request chạy lần lượt: thời gian xấp xỉ tổng thời gian các URL (giống chạy tuần tự). Với Semaphore(10), cả 10 chạy cùng lúc: thời gian xấp xỉ URL chậm nhất (bị chặn ở 3 giây bởi timeout). Giá trị 3 nằm giữa: đủ nhanh mà không dồn quá nhiều kết nối vào cùng một máy chủ.

Bài 2. Timeout từng tác vụ

Viết chương trình chạy 6 tác vụ giả lập với thời gian chờ [0.1, 0.4, 2.0, 0.2, 3.0, 0.3] giây, mỗi tác vụ tối đa 1 giây; tác vụ quá hạn ghi là "quá thời gian". Tổng thời gian phải khoảng 1 giây.

Xem đáp án
import asyncio
import time


async def tac_vu(i: int, giay: float) -> str:
    try:
        async with asyncio.timeout(1):
            await asyncio.sleep(giay)
            return f"#{i} xong sau {giay}s"
    except TimeoutError:
        return f"#{i} quá thời gian"


async def main() -> None:
    t = time.perf_counter()
    async with asyncio.TaskGroup() as tg:
        viec = [tg.create_task(tac_vu(i, g)) for i, g in enumerate([0.1, 0.4, 2.0, 0.2, 3.0, 0.3])]
    for v in viec:
        print(v.result())
    print(f"Tổng: {time.perf_counter() - t:.1f} s")


asyncio.run(main())
#0 xong sau 0.1s
#1 xong sau 0.4s
#2 quá thời gian
#3 xong sau 0.2s
#4 quá thời gian
#5 xong sau 0.3s
Tổng: 1.0 s

Tác vụ 2 và 4 bị hủy ở giây thứ nhất thay vì chờ 2 và 3 giây. Không có timeout, tổng thời gian sẽ là 3 giây; trong hệ thống thật, một dịch vụ chậm không được phép kéo chậm cả chương trình.

Nguồn tham khảo: asyncio; Coroutines and Tasks (TaskGroup, timeout); HTTPX: Async Support; FastAPI: Concurrency and async / await.

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

  1. Viết chương trình async kiểm tra 10 URL còn sống không, giới hạn 3 kết nối cùng lúc.
  2. Thêm timeout cho từng URL bằng asyncio.timeout, URL quá hạn ghi là 'quá thời gian'.

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í.