Event-Loop on Tarragon

1.1 基礎概念與事件迴圈

Tue, 20 Jan 2026 00:00:00 +0000

本章介紹 asyncio 的核心概念。理解這些概念是掌握異步程式設計的基礎。

先備知識

入門系列 3.7 並行處理
了解 I/O 密集任務的特性

本章目標

學完本章後，你將能夠：

理解並發、並行、異步的區別
解釋事件迴圈的工作原理
寫出第一個異步程式
判斷何時使用 asyncio

【原理層】並發、並行與異步

三個容易混淆的概念

在開始之前，我們需要釐清三個經常被混用的概念：

 1並發（Concurrency）：
 2  同時「處理」多件事情（不一定同時執行）
 3  重點是結構和設計
 4
 5並行（Parallelism）：
 6  同時「執行」多件事情
 7  需要多核 CPU 或多台機器
 8
 9異步（Asynchronous）：
10  不等待結果就繼續執行
11  一種實現並發的方式

用一個生活化的例子：

 1同步做早餐：
 2  1. 煮咖啡（等 5 分鐘）
 3  2. 烤土司（等 3 分鐘）
 4  3. 煎蛋（等 4 分鐘）
 5  總共：12 分鐘
 6
 7異步做早餐（一個人）：
 8  1. 啟動咖啡機
 9  2. 放土司進烤箱
10  3. 開始煎蛋
11  4. 等待全部完成
12  總共：約 5 分鐘（最長任務的時間）
13
14並行做早餐（三個人）：
15  三人同時分別處理
16  總共：約 5 分鐘

asyncio 是並發，不是並行

這是最重要的概念：asyncio 在單執行緒中實現並發。

 1import asyncio
 2import time
 3
 4async def task(name, delay):
 5    print(f"{name} 開始")
 6    await asyncio.sleep(delay)  # 非阻塞等待
 7    print(f"{name} 完成")
 8    return name
 9
10async def main():
11    start = time.perf_counter()
12
13    # 同時啟動三個任務
14    results = await asyncio.gather(
15        task("A", 2),
16        task("B", 1),
17        task("C", 1.5)
18    )
19
20    elapsed = time.perf_counter() - start
21    print(f"總耗時：{elapsed:.2f}s")  # 約 2 秒，不是 4.5 秒
22
23asyncio.run(main())

輸出：

1A 開始
2B 開始
3C 開始
4B 完成
5C 完成
6A 完成
7總耗時：2.00s

三個任務「並發」執行，但都在同一個執行緒中。

為什麼不用多執行緒？

你可能會問：用 threading 也能達到類似效果，為什麼要用 asyncio？

面向	threading	asyncio
記憶體開銷	每執行緒約 8MB stack	每協程約幾 KB
切換成本	OS 排程，較高	用戶空間切換，極低
並發數量	數百到數千	數萬到數十萬
執行緒安全	需要鎖保護	單執行緒，天生安全
除錯難度	競爭條件難以重現	確定性較高

當你需要處理大量 I/O 並發（如 Web 伺服器、爬蟲）時，asyncio 通常是更好的選擇。

【設計層】事件迴圈

什麼是事件迴圈？

事件迴圈（Event Loop）是 asyncio 的核心，它負責：

排程和執行協程
處理 I/O 事件
管理回呼函式

 1事件迴圈的運作：
 2
 3┌─────────────────────────────────────┐
 4│           事件迴圈                    │
 5│  ┌─────────────────────────────┐    │
 6│  │    就緒佇列（Ready Queue）    │    │
 7│  │  [協程A] [協程B] [協程C]      │    │
 8│  └─────────────────────────────┘    │
 9│              ↓                       │
10│         執行就緒任務                  │
11│              ↓                       │
12│         遇到 await                   │
13│              ↓                       │
14│  ┌─────────────────────────────┐    │
15│  │   等待佇列（Waiting Queue）   │    │
16│  │  [等待 I/O] [等待計時器]      │    │
17│  └─────────────────────────────┘    │
18│              ↓                       │
19│         I/O 完成                     │
20│              ↓                       │
21│         放回就緒佇列                  │
22└─────────────────────────────────────┘

協作式多任務

asyncio 使用「協作式多任務」（Cooperative Multitasking）：

任務主動讓出控制權（透過 await）
事件迴圈選擇下一個就緒任務執行
沒有強制搶佔

 1async def cooperative_task(name):
 2    for i in range(3):
 3        print(f"{name}: 步驟 {i}")
 4        await asyncio.sleep(0)  # 主動讓出控制權
 5    print(f"{name}: 完成")
 6
 7async def main():
 8    await asyncio.gather(
 9        cooperative_task("A"),
10        cooperative_task("B")
11    )
12
13asyncio.run(main())

輸出：

1A: 步驟 0
2B: 步驟 0
3A: 步驟 1
4B: 步驟 1
5A: 步驟 2
6B: 步驟 2
7A: 完成
8B: 完成

注意任務是交替執行的，每次 await 都是一個切換點。

asyncio.run() 的背後

asyncio.run() 是 Python 3.7+ 推薦的入口點：

1# 這是簡化的偽代碼
2def run(coro):
3    loop = asyncio.new_event_loop()
4    try:
5        asyncio.set_event_loop(loop)
6        return loop.run_until_complete(coro)
7    finally:
8        loop.close()

它做了三件事：

建立新的事件迴圈
執行協程直到完成
關閉事件迴圈

【實作層】第一個異步程式

async 和 await

 1import asyncio
 2
 3# async def 定義協程函式
 4async def greet(name, delay):
 5    print(f"開始問候 {name}")
 6    await asyncio.sleep(delay)  # await 等待可等待物件
 7    print(f"你好，{name}！")
 8    return f"問候 {name} 完成"
 9
10async def main():
11    # 方法 1：依序執行
12    result1 = await greet("Alice", 1)
13    result2 = await greet("Bob", 1)
14    # 總共約 2 秒
15
16    # 方法 2：並發執行
17    results = await asyncio.gather(
18        greet("Charlie", 1),
19        greet("David", 1)
20    )
21    # 總共約 1 秒
22
23asyncio.run(main())

協程 vs 協程函式

這是一個常見的混淆點：

 1async def my_coro():
 2    return 42
 3
 4# my_coro 是協程函式（coroutine function）
 5print(type(my_coro))  # 
 6
 7# my_coro() 是協程物件（coroutine object）
 8coro = my_coro()
 9print(type(coro))  # 
10
11# 協程物件需要被執行
12result = asyncio.run(coro)
13print(result)  # 42

常見錯誤：忘記 await

 1async def fetch_data():
 2    await asyncio.sleep(1)
 3    return {"data": "value"}
 4
 5async def main():
 6    # 錯誤：沒有 await
 7    result = fetch_data()  # 這只是建立協程物件，沒有執行
 8    print(result)  # 
 9
10    # 正確：使用 await
11    result = await fetch_data()
12    print(result)  # {'data': 'value'}
13
14asyncio.run(main())

Python 會發出警告：

1RuntimeWarning: coroutine 'fetch_data' was never awaited

偵錯技巧

 1import asyncio
 2
 3async def main():
 4    # 取得當前事件迴圈
 5    loop = asyncio.get_running_loop()
 6    print(f"事件迴圈：{loop}")
 7
 8    # 檢查是否在事件迴圈中
 9    print(f"正在執行：{loop.is_running()}")
10
11asyncio.run(main())

【選擇指南】何時使用 asyncio

適合 asyncio 的場景

Web 伺服器：處理大量並發請求
API 客戶端：批次呼叫多個 API
網路爬蟲：同時抓取多個網頁
即時應用：WebSocket、聊天室
資料庫操作：批次查詢

 1# 範例：並發下載多個網頁
 2import asyncio
 3import aiohttp
 4
 5async def fetch(session, url):
 6    async with session.get(url) as response:
 7        return await response.text()
 8
 9async def main():
10    urls = [
11        "https://python.org",
12        "https://docs.python.org",
13        "https://pypi.org"
14    ]
15
16    async with aiohttp.ClientSession() as session:
17        tasks = [fetch(session, url) for url in urls]
18        results = await asyncio.gather(*tasks)
19
20    for url, html in zip(urls, results):
21        print(f"{url}: {len(html)} bytes")
22
23asyncio.run(main())

不適合 asyncio 的場景

CPU 密集任務：asyncio 無法繞過 GIL
簡單腳本：增加複雜度沒有好處
依賴同步函式庫：需要額外處理

決策流程

 1任務類型？
 2    │
 3    ├─→ CPU 密集
 4    │       └─→ multiprocessing 或 Free-threading
 5    │
 6    └─→ I/O 密集
 7            │
 8            ├─→ 並發量 < 100
 9            │       └─→ threading 可能夠用
10            │
11            └─→ 並發量 > 100
12                    │
13                    ├─→ 需要共享複雜狀態
14                    │       └─→ threading + Lock
15                    │
16                    └─→ 任務相對獨立
17                            └─→ asyncio（推薦）

思考題

為什麼說 asyncio 是「協作式」而不是「搶佔式」？這對程式設計有什麼影響？
如果一個協程中有 CPU 密集的計算而沒有 await，會發生什麼事？
asyncio.sleep(0) 的作用是什麼？

實作練習

寫一個程式，同時「下載」5 個檔案（用 asyncio.sleep() 模擬下載時間），並顯示總耗時
修改上面的程式，讓它顯示每個檔案完成的順序
實作一個簡單的計時器，每秒印出一次時間，持續 5 秒

延伸閱讀

下一章：協程與 Task 管理

1.2 協程與 Task 管理

Tue, 20 Jan 2026 00:00:00 +0000

本章深入探討協程的執行機制，以及如何使用 Task 管理並發任務。

先備知識

1.1 基礎概念與事件迴圈

本章目標

學完本章後，你將能夠：

理解協程、Task、Future 的區別與關係
使用 create_task() 建立並發任務
使用 gather()、wait() 和 TaskGroup 管理多個任務
正確處理任務取消與超時

【原理層】可等待物件

協程、Task、Future

在 asyncio 中，有三種「可等待物件」（Awaitable）：

 1import asyncio
 2
 3# 1. 協程（Coroutine）
 4async def my_coroutine():
 5    return 42
 6
 7# 2. Task - 協程的包裝，可追蹤狀態
 8task = asyncio.create_task(my_coroutine())
 9
10# 3. Future - 底層的「未來結果」容器
11future = asyncio.Future()

它們的關係：

 1         ┌─────────────────────┐
 2         │     Awaitable       │
 3         │   （可等待物件）      │
 4         └─────────────────────┘
 5                   ▲
 6         ┌─────────┼─────────┐
 7         │         │         │
 8    Coroutine   Future     Task
 9     （協程）   （未來）  （任務）
10                   ▲
11                   │
12                 Task
13           （Task 繼承自 Future）

await 的語義

當你 await 一個物件時：

如果結果已就緒，立即返回
如果結果未就緒，暫停當前協程，讓出控制權
當結果就緒時，恢復執行

 1async def demo():
 2    # await 協程
 3    result1 = await some_coroutine()
 4
 5    # await Task
 6    task = asyncio.create_task(some_coroutine())
 7    result2 = await task
 8
 9    # await Future
10    future = asyncio.Future()
11    # ... 某處設定 future.set_result(value)
12    result3 = await future

【設計層】Task 管理

create_task() 的時機

create_task() 將協程包裝成 Task 並排程執行：

 1async def worker(name, delay):
 2    print(f"{name} 開始")
 3    await asyncio.sleep(delay)
 4    print(f"{name} 完成")
 5    return f"{name} 結果"
 6
 7async def main():
 8    # 方法 1：依序執行（不並發）
 9    result1 = await worker("A", 1)
10    result2 = await worker("B", 1)
11    # 總時間：2 秒
12
13    # 方法 2：先建立 Task，再 await（並發）
14    task1 = asyncio.create_task(worker("C", 1))
15    task2 = asyncio.create_task(worker("D", 1))
16    result3 = await task1
17    result4 = await task2
18    # 總時間：1 秒
19
20asyncio.run(main())

重要：create_task() 會立即排程任務，即使你還沒 await 它。

gather() vs wait() vs TaskGroup

三種管理多個任務的方式：

 1async def main():
 2    tasks = [worker(f"Task-{i}", 1) for i in range(3)]
 3
 4    # gather()：等待所有完成，返回結果列表
 5    results = await asyncio.gather(*tasks)
 6
 7    # wait()：更細緻的控制
 8    done, pending = await asyncio.wait(
 9        tasks,
10        return_when=asyncio.FIRST_COMPLETED  # 或 ALL_COMPLETED
11    )
12
13    # TaskGroup（Python 3.11+）：結構化並發
14    async with asyncio.TaskGroup() as tg:
15        task1 = tg.create_task(worker("A", 1))
16        task2 = tg.create_task(worker("B", 1))
17    # 離開 context 時，所有任務都已完成

方法	特點	使用場景
`gather()`	簡單，返回結果列表	等待所有任務完成
`wait()`	可選擇等待策略	需要處理先完成的任務
`TaskGroup`	結構化，異常處理更好	Python 3.11+，推薦使用

【實作層】任務生命週期

任務狀態

 1async def demo():
 2    task = asyncio.create_task(asyncio.sleep(1))
 3
 4    print(f"已完成：{task.done()}")      # False
 5    print(f"已取消：{task.cancelled()}")  # False
 6
 7    await task
 8
 9    print(f"已完成：{task.done()}")      # True
10    print(f"結果：{task.result()}")      # None（sleep 返回 None）

取消任務

 1async def long_running():
 2    try:
 3        await asyncio.sleep(10)
 4    except asyncio.CancelledError:
 5        print("任務被取消")
 6        raise  # 重要：要重新拋出
 7
 8async def main():
 9    task = asyncio.create_task(long_running())
10    await asyncio.sleep(1)  # 讓任務開始
11    task.cancel()           # 請求取消
12
13    try:
14        await task
15    except asyncio.CancelledError:
16        print("確認已取消")

超時控制

 1async def main():
 2    # 方法 1：wait_for
 3    try:
 4        result = await asyncio.wait_for(long_running(), timeout=2.0)
 5    except asyncio.TimeoutError:
 6        print("超時")
 7
 8    # 方法 2：timeout（Python 3.11+）
 9    try:
10        async with asyncio.timeout(2.0):
11            result = await long_running()
12    except asyncio.TimeoutError:
13        print("超時")

【常見錯誤】

1. 協程從未執行

1async def main():
2    # 錯誤：只建立了協程物件，沒有執行
3    worker("A", 1)  # RuntimeWarning!
4
5    # 正確
6    await worker("A", 1)

2. Task 被垃圾回收

1async def main():
2    # 錯誤：task 沒有被引用，可能被 GC
3    asyncio.create_task(worker("A", 1))
4
5    # 正確：保持引用
6    task = asyncio.create_task(worker("A", 1))
7    await task

3. 異常被吞掉

1async def failing_task():
2    raise ValueError("出錯了")
3
4async def main():
5    task = asyncio.create_task(failing_task())
6    await asyncio.sleep(1)  # 異常不會在這裡拋出
7    # 必須 await task 才會看到異常

思考題

await task 和 await asyncio.gather(task) 有什麼區別？
為什麼 CancelledError 要重新拋出？
TaskGroup 相比 gather() 有什麼優勢？

實作練習

實作一個函式，並發執行多個任務，但限制同時執行的數量（提示：使用 Semaphore）
實作一個「競速」函式，返回最先完成的任務結果
實作一個任務管理器，可以動態新增和取消任務

延伸閱讀

上一章：基礎概念與事件迴圈 下一章：設計模式與最佳實踐

從 threading 到 asyncio：轉換指南

Wed, 21 Jan 2026 00:00:00 +0000

如果你已經熟悉入門系列的 threading 模組，本章將幫助你理解為什麼需要 asyncio，以及如何將現有的多執行緒程式碼轉換為異步版本。

為什麼要從 threading 轉向 asyncio？

threading 的限制

threading 是處理並發的傳統方案，但它有幾個固有限制：

1. 資源消耗高

每個執行緒都需要分配記憶體（預設約 8MB stack）：

1import threading
2
3# 建立 100 個執行緒
4threads = [threading.Thread(target=some_task) for _ in range(100)]
5# 記憶體消耗：約 800MB 的 stack 空間

當需要處理數千個並發連線時，執行緒模型會面臨資源瓶頸。

2. 上下文切換成本

作業系統需要在執行緒之間切換，這涉及：

保存和恢復 CPU 暫存器
切換記憶體映射
快取失效

1執行緒 1 執行 → 上下文切換（耗時）→ 執行緒 2 執行 → 上下文切換（耗時）→ ...

3. GIL 的限制

由於 GIL，多個執行緒無法真正並行執行 Python 程式碼：

1# 這段程式碼實際上是序列執行的
2def cpu_task():
3    total = 0
4    for i in range(1000000):
5        total += i
6    return total
7
8# 即使使用多執行緒，也無法利用多核 CPU
9threads = [threading.Thread(target=cpu_task) for _ in range(4)]

asyncio 的優勢

asyncio 採用不同的並發模型來解決這些問題：

1. 輕量級協程

協程只是普通的 Python 物件，記憶體消耗極低：

1import asyncio
2
3# 建立 10000 個協程
4async def some_task():
5    await asyncio.sleep(1)
6
7# 記憶體消耗：幾十 KB
8tasks = [some_task() for _ in range(10000)]

2. 協作式切換

協程只在 await 點切換，沒有強制的上下文切換：

1協程 1 執行 → await（主動讓出）→ 協程 2 執行 → await（主動讓出）→ ...

3. 單執行緒高並發

asyncio 在單執行緒中處理所有任務，避免了執行緒同步問題：

1async def handle_request(client):
2    data = await client.read()    # 等待時處理其他請求
3    result = process(data)
4    await client.write(result)    # 等待時處理其他請求

並發模型比較

特性	threading	asyncio
執行模型	多執行緒並行	單執行緒協作
切換方式	作業系統搶佔	程式主動讓出
記憶體消耗	高（每執行緒 ~8MB）	低（每協程 ~KB）
並發數量	百級	萬級
GIL 影響	受限制	無影響（不需要多核）
同步複雜度	需要鎖（Lock、Semaphore）	較少（單執行緒）
適用場景	I/O 密集 + 共享記憶體	I/O 密集 + 大規模並發

程式碼轉換模式

模式 1：簡單函式轉換

threading 版本：

 1import time
 2import threading
 3
 4def fetch_data(url):
 5    time.sleep(1)  # 模擬網路延遲
 6    return f"Data from {url}"
 7
 8def main():
 9    urls = ["url1", "url2", "url3"]
10    threads = []
11    results = []
12
13    for url in urls:
14        t = threading.Thread(target=lambda u=url: results.append(fetch_data(u)))
15        threads.append(t)
16        t.start()
17
18    for t in threads:
19        t.join()
20
21    return results

asyncio 版本：

 1import asyncio
 2
 3async def fetch_data(url):
 4    await asyncio.sleep(1)  # 非阻塞等待
 5    return f"Data from {url}"
 6
 7async def main():
 8    urls = ["url1", "url2", "url3"]
 9
10    # 使用 gather 並發執行
11    results = await asyncio.gather(*[fetch_data(url) for url in urls])
12
13    return results
14
15# 執行
16asyncio.run(main())

轉換要點：

原本	轉換後
`def`	`async def`
`time.sleep()`	`await asyncio.sleep()`
`threading.Thread` + `join`	`asyncio.gather()`

模式 2：ThreadPoolExecutor 轉換

threading 版本：

1from concurrent.futures import ThreadPoolExecutor
2
3def process_file(filepath):
4    with open(filepath) as f:
5        return len(f.read())
6
7with ThreadPoolExecutor(max_workers=4) as executor:
8    results = list(executor.map(process_file, file_paths))

asyncio 版本（使用 aiofiles）：

 1import asyncio
 2import aiofiles
 3
 4async def process_file(filepath):
 5    async with aiofiles.open(filepath) as f:
 6        content = await f.read()
 7        return len(content)
 8
 9async def main():
10    tasks = [process_file(fp) for fp in file_paths]
11    results = await asyncio.gather(*tasks)
12    return results
13
14asyncio.run(main())

模式 3：保留同步程式碼（混合模式）

有時候你無法（或不想）將所有程式碼都轉為異步。asyncio 提供了 run_in_executor 來處理這種情況：

 1import asyncio
 2from concurrent.futures import ThreadPoolExecutor
 3
 4# 保持原有的同步函式
 5def blocking_operation(data):
 6    # 這是一個阻塞的第三方函式庫呼叫
 7    import time
 8    time.sleep(1)
 9    return f"Processed: {data}"
10
11async def main():
12    loop = asyncio.get_event_loop()
13
14    # 在執行緒池中執行同步函式
15    with ThreadPoolExecutor() as pool:
16        result = await loop.run_in_executor(
17            pool,
18            blocking_operation,
19            "my_data"
20        )
21
22    return result
23
24asyncio.run(main())

這種模式讓你可以漸進式地將程式碼遷移到 asyncio。

何時選擇哪種方案？

選擇 threading

需要與不支援 asyncio 的函式庫整合
需要共享記憶體且修改頻繁
並發數量較少（< 100）
團隊對 threading 更熟悉

選擇 asyncio

需要處理大量並發連線（Web 伺服器、聊天室）
主要是 I/O 操作（網路、檔案）
使用現代 async 函式庫（aiohttp、httpx、asyncpg）
需要高效能的單機並發

選擇 multiprocessing

CPU 密集任務（資料處理、科學計算）
需要真正的並行計算
各任務相對獨立，不需要頻繁通訊

決策流程圖

 1任務類型是什麼？
 2    │
 3    ├─ CPU 密集 ────────────────→ multiprocessing
 4    │
 5    └─ I/O 密集
 6        │
 7        ├─ 並發數 > 100 ─────────→ asyncio
 8        │
 9        ├─ 需要共享記憶體 ────────→ threading
10        │
11        └─ 第三方函式庫支援 async？
12            │
13            ├─ 是 ───────────────→ asyncio
14            │
15            └─ 否 ───────────────→ threading 或 asyncio + run_in_executor

常見轉換陷阱

陷阱 1：忘記 await

1# 錯誤：忘記 await
2async def main():
3    result = fetch_data("url")  # 這只會建立協程物件，不會執行
4    print(result)  # 
5
6# 正確
7async def main():
8    result = await fetch_data("url")
9    print(result)

陷阱 2：在異步函式中使用阻塞呼叫

1# 錯誤：使用阻塞的 time.sleep
2async def bad_sleep():
3    time.sleep(1)  # 這會阻塞整個事件迴圈！
4
5# 正確：使用非阻塞的 asyncio.sleep
6async def good_sleep():
7    await asyncio.sleep(1)  # 這會讓出控制權

陷阱 3：在同步函式中呼叫異步函式

1# 錯誤：在普通函式中直接呼叫
2def sync_function():
3    result = await fetch_data("url")  # SyntaxError!
4
5# 正確：使用 asyncio.run
6def sync_function():
7    result = asyncio.run(fetch_data("url"))

實戰練習

練習 1：轉換簡單的多執行緒下載器

將以下 threading 程式碼轉換為 asyncio 版本：

 1import threading
 2import time
 3
 4def download(url):
 5    print(f"Downloading {url}...")
 6    time.sleep(2)  # 模擬下載
 7    print(f"Finished {url}")
 8    return f"Content of {url}"
 9
10def main():
11    urls = ["url1", "url2", "url3", "url4"]
12    threads = []
13
14    for url in urls:
15        t = threading.Thread(target=download, args=(url,))
16        threads.append(t)
17        t.start()
18
19    for t in threads:
20        t.join()
21
22if __name__ == "__main__":
23    main()

練習 2：使用 run_in_executor 整合同步函式庫

假設你有一個只支援同步的第三方 API 客戶端，寫一個異步包裝器。

下一步

理解了 threading 和 asyncio 的區別後，你可以開始深入學習 asyncio 的核心概念：

1.1 基礎概念與事件迴圈 - 理解 asyncio 的運作原理
1.2 協程與 Task 管理 - 掌握 async/await 語法
1.4 實戰：與同步程式碼整合 - 學習混合模式的最佳實踐

上一章：入門系列 3.7 並行處理 下一章：1.1 基礎概念與事件迴圈