async/await với asyncio hoạt động như thế nào?

Question

IT Interview Practice · Accepted Answer

**asyncio** là framework của Python cho **I/O đồng thời (concurrent)** dùng `async`/`await`. Nó chạy nhiều thao tác I/O một cách hợp tác trên một **thread duy nhất** thông qua một event loop — hiệu quả cho công việc I/O-bound có độ đồng thời cao (lời gọi mạng, web server) mà không có chi phí của thread.

## Định nghĩa và chạy coroutine

```python
import asyncio

async def fetch_data(id):       # một hàm async = một coroutine
    print(f"start {id}")
    await asyncio.sleep(1)       # await một thao tác I/O không chặn (nhường quyền điều khiển)
    print(f"done {id}")
    return id

asyncio.run(fetch_data(1))       # chạy một coroutine từ code đồng bộ
```

Một hàm `async def` là một **coroutine**; `await` tạm dừng nó tại một điểm I/O, cho phép event loop chạy *các* coroutine khác trong lúc đó — rồi tiếp tục khi thao tác được await hoàn thành.

## Lợi ích then chốt: I/O đồng thời

```python
# ❌ tuần tự — tổng thời gian ≈ 3 giây
async def slow():
    await fetch_data(1)   # chờ 1s
    await fetch_data(2)   # rồi chờ 1s
    await fetch_data(3)   # rồi chờ 1s

# ✅ đồng thời — tổng thời gian ≈ 1 giây (tất cả chạy cùng nhau)
async def fast():
    await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
```

`asyncio.gather` chạy các coroutine **đồng thời** — trong khi một cái await I/O, các cái khác tiến hành. Ba lần chờ 1-giây chồng lấp thành tổng cộng ~1 giây. Đây là giá trị cốt lõi: chồng lấp nhiều lần chờ I/O trên một thread.

## Nó khác với thread như thế nào

```text
Threading:  do OS quản lý, ưu tiên (preemptive), thread thực (bị giới hạn bởi GIL với CPU)
asyncio:    một thread, HỢP TÁC — coroutine nhường quyền tại các điểm `await`
            → nhẹ hơn (xử lý hàng nghìn kết nối), không chi phí thread,
              nhưng một coroutine nặng CPU sẽ chặn mọi thứ (không có ưu tiên)
```

## Quy tắc tối thượng: đừng chặn event loop

```python
async def bad():
    time.sleep(5)              # ❌ CHẶN toàn bộ event loop (sleep đồng bộ)
    result = heavy_compute()    # ❌ công việc CPU đóng băng mọi coroutine

async def good():
    await asyncio.sleep(5)      # ✅ không chặn
    # chuyển công việc CPU sang một thread/process pool
    await loop.run_in_executor(None, heavy_compute)
```

Vì nó hợp tác và đơn-thread, bất kỳ lời gọi chặn/nặng-CPU nào sẽ đóng băng *mọi* coroutine. Dùng các API async có thể `await`, và chuyển công việc chặn/CPU sang một executor.

## Nơi asyncio tỏa sáng

```text
✓ I/O độ đồng thời cao: web server (FastAPI), web scraping, nhiều lời gọi API/DB,
  websocket, ứng dụng thời gian thực — hàng nghìn kết nối đồng thời một cách hiệu quả
✗ Công việc CPU-bound — dùng multiprocessing thay thế (asyncio không giúp được)
```

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

asyncio là cách tiếp cận hiện đại cho **I/O độ đồng thời cao** trong Python, vận hành các framework như FastAPI và cho phép xử lý hiệu quả hàng nghìn kết nối đồng thời trên một thread — nhẹ hơn nhiều so với một-thread-mỗi-kết-nối.

Hiểu coroutine, `await`, thực thi đồng thời với `gather`, và đặc biệt là **quy tắc tối thượng** (đừng bao giờ chặn event loop; chuyển công việc CPU/chặn ra ngoài) là thiết yếu để viết Python async có hiệu năng.

Biết khi nào nó phù hợp (đồng thời I/O-bound) so với khi nào không (CPU-bound → multiprocessing) là then chốt để dùng nó hiệu quả.

Định nghĩa và chạy coroutine

Lợi ích then chốt: I/O đồng thời

Nó khác với thread như thế nào

Quy tắc tối thượng: đừng chặn event loop

Nơi asyncio tỏa sáng

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

Câu hỏi liên quan