协程能够暂停和恢复,但协程本身不知道应该在什么时候恢复,也不知道暂停期间应该运行谁。事件循环(event loop)就是负责这项工作的调度器。
假设程序中有三个任务:
事件循环不会一直守着任务 A。它会先运行已经就绪的任务 C,同时监听任务 A 和任务 B 等待的 IO。某个 IO 完成后,对应任务重新获得运行资格,事件循环再选择合适的时机恢复它。
事件循环主要负责:
call_soon()
事件循环不是线程池,也不是让代码自动并发的语法。通常一个事件循环运行在一个操作系统线程中,这个线程在同一时刻只执行一个 Task 或回调。任务必须运行到 await、结束或抛出异常,事件循环才有机会运行其他任务。
await
因此,asyncio 采用的是协作式调度:任务主动在可等待的位置让出执行权,而不是由事件循环在任意一行代码上强制打断任务。
asyncio
理解事件循环之前,需要先看清它周围的几个对象:
它们之间的关系可以简化为:
协程对象包装为 Task 后进入就绪状态。事件循环运行 Task;遇到尚未完成的 await 时暂停,等待 Future 或 IO。结果完成后,Task 重新就绪,由事件循环恢复执行。
FLOW / RELATIONSHIP
协程对象
一次异步函数调用
Task
包装协程,进入就绪状态
事件循环运行 Task
推进协程执行
暂停等待
尚未完成的 await / Future / IO
Task 重新就绪
等待的结果已经完成
事件循环恢复 Task
继续执行协程
Task 是事件循环真正调度的协程执行单元。Future 更像结果占位符:结果没有准备好时,等待它的 Task 暂停;Future 完成后,会安排等待它的 Task 重新进入就绪状态。
事件循环不会不停遍历所有暂停的协程,询问它们是否完成。IO 监听器、定时器和 Future 会在条件满足时通知事件循环,把相关工作重新放回可运行的集合中。
「就绪队列」「定时器集合」和「IO 监听器」适合用来建立概念模型。不同操作系统和事件循环实现的内部数据结构可能不同,业务代码不应该依赖它们的具体实现细节。
一次事件循环迭代可以大致理解为以下步骤:
这是便于学习的简化过程,不是要求应用开发者手写的循环。平时使用 asyncio.run(),Python 会负责驱动事件循环。
asyncio.run()
下面可以观察两个 Task 如何交替执行:
01import asyncio 02 03async def worker(name): 04 print(f"{name}:开始") 05 await asyncio.sleep(0) 06 print(f"{name}:恢复") 07 08async def main(): 09 print("main:创建任务") 10 first = asyncio.create_task(worker("任务一")) 11 second = asyncio.create_task(worker("任务二")) 12 13 print("main:等待任务") 14 await asyncio.gather(first, second) 15 print("main:结束") 16 17asyncio.run(main())
通常可以观察到下面的顺序:
1main:创建任务 2main:等待任务 3任务一:开始 4任务二:开始 5任务一:恢复 6任务二:恢复 7main:结束
create_task() 把两个协程包装成 Task,并安排它们运行。main() 执行到 await gather(...) 后暂停,事件循环开始推进两个子任务。
create_task()
main()
await gather(...)
示例中的 await asyncio.sleep(0) 不是真的等待时间,而是主动暂停当前 Task,让事件循环有机会运行其他就绪任务。它适合演示调度,不应该被当成修复阻塞代码的通用办法。
await asyncio.sleep(0)
协作式调度意味着公平性不是自动保证的。如果一个 Task 长时间计算且没有遇到 await,它会一直占用事件循环线程:
1async def calculate(): 2 total = 0 3 for number in range(50_000_000): 4 total += number 5 6 return total
虽然 calculate() 使用了 async def,但函数内部没有真正的等待点。它开始运行后,其他 Task 只能等它计算结束。
calculate()
async def
IO 是 Input/Output(输入/输出)的缩写。在异步服务中,它通常表示等待网络、数据库、文件或其他外部资源。socket 可以先理解为程序与网络连接交互的对象。
异步 IO 的关键不是反复询问网络请求有没有完成,而是把等待交给操作系统。
以异步 HTTP 请求为例,可以把过程理解为:
底层通常依赖操作系统提供的高效 IO 机制,例如 Linux 的 epoll、macOS 的 kqueue 和 Windows 的 IOCP。具体实现会因平台与 Python 版本而不同,但核心目标都是让一个线程同时管理大量处于等待状态的连接。
epoll
kqueue
所以,异步 HTTP 通常不是「一个 HTTP 请求对应一个线程」,也不需要事件循环额外创建一个「HTTP 线程」。事件循环所在的线程负责运行 Python 回调和 Task,操作系统负责监控大量 IO 状态。
定时等待也是类似的思路:
1import asyncio 2 3async def remind(): 4 print("开始等待") 5 await asyncio.sleep(2) 6 print("恢复执行") 7 8asyncio.run(remind())
asyncio.sleep(2) 会注册定时等待并暂停当前 Task,通常不会创建一个专门的定时器线程。两秒后只表示这个 Task 具备恢复资格;如果事件循环此时正在执行其他代码,实际恢复时间可能稍晚。
asyncio.sleep(2)
大多数业务代码只需要协程和高层 API,但事件循环也提供了调度普通回调的低层接口:
loop.call_soon()
loop.call_later()
loop.call_at()
loop.call_soon_threadsafe()
asyncio.run_coroutine_threadsafe()
01import asyncio 02 03def ready_callback(): 04 print("就绪回调") 05 06def timer_callback(): 07 print("定时回调") 08 09async def main(): 10 loop = asyncio.get_running_loop() 11 12 ready_handle = loop.call_soon(ready_callback) 13 timer_handle = loop.call_later(1, timer_callback) 14 15 print(type(ready_handle).__name__) 16 print(type(timer_handle).__name__) 17 await asyncio.sleep(1.2) 18 19asyncio.run(main())
call_soon() 返回 Handle,call_later() 返回 TimerHandle。只要回调尚未执行,就可以通过它们的 cancel() 方法取消调度。
call_later()
cancel()
call_later() 使用相对延迟,call_at() 使用与 loop.time() 相同的单调时钟。单调时钟只适合计算时间间隔,不应该把 loop.time() 当成日期时间戳。
call_at()
loop.time()
这些回调是普通同步函数。回调一旦开始运行,在返回之前会占用事件循环线程,因此回调内容也应该保持短小,不能直接执行阻塞 IO 或长时间计算。
大部分 asyncio 对象都不是线程安全的。在事件循环线程之外调用 call_soon() 并不安全,必须使用 call_soon_threadsafe();从其他线程提交协程时,则使用 run_coroutine_threadsafe()。
call_soon_threadsafe()
run_coroutine_threadsafe()
Python asyncio 没有 JavaScript 那种公开且严格对应的「宏任务队列」和「微任务队列」。call_soon()、Task 恢复、Future 完成和定时回调都遵循 asyncio 自己的调度规则,不应该机械套用 Promise.then() 与 setTimeout() 的优先级结论。
Promise.then()
setTimeout()
普通 Python 程序应该优先使用 asyncio.run() 作为异步入口:
01import asyncio 02 03async def main(): 04 loop = asyncio.get_running_loop() 05 print(loop.is_running()) # True 06 await asyncio.sleep(0.1) 07 return "完成" 08 09result = asyncio.run(main()) 10print(result)
asyncio.run() 会完成一整套生命周期管理:
asyncio.run() 不能在同一线程已经运行事件循环时再次调用。FastAPI、异步测试框架和部分交互式环境已经管理事件循环,此时应该直接 await:
1async def load_data(): 2 return "数据" 3 4async def endpoint(): 5 return await load_data() 6 7# 不要在 endpoint() 中调用 asyncio.run(load_data())
在协程和回调内部需要取得当前事件循环时,优先使用 asyncio.get_running_loop()。旧教程经常展示 get_event_loop()、new_event_loop()、run_forever() 和手动 close(),这些是低层控制接口,不是普通应用的首选写法。事件循环 policy 体系也已经弃用,因此不建议新项目把 policy 配置作为主线方案。
asyncio.get_running_loop()
get_event_loop()
new_event_loop()
run_forever()
close()
事件循环不能解决同步阻塞代码。下面的接口会让同一事件循环上的其他 Task 一起等待:
1import time 2 3async def bad_task(): 4 time.sleep(3) 5 return "完成"
优先把同步库替换为异步库。确实无法替换的短时间阻塞 IO,可以使用 asyncio.to_thread() 隔离:
asyncio.to_thread()
01import asyncio 02import time 03 04def blocking_work(): 05 time.sleep(1) 06 return "完成" 07 08async def main(): 09 result = await asyncio.to_thread(blocking_work) 10 print(result) 11 12asyncio.run(main())
开发阶段还可以启用调试模式,帮助发现忘记等待的协程、错误的跨线程调用和执行时间过长的回调:
1import asyncio 2 3async def main(): 4 await asyncio.sleep(0.1) 5 6asyncio.run(main(), debug=True)
调试模式会增加额外开销,适合开发和排查问题,不应在不了解成本的情况下直接作为高负载生产环境默认配置。
使用当前事件循环注册回调、取消 TimerHandle,并让两个 Task 主动让出执行权。
入口和主题代码与工作区直接共用同一份来源:
01from fastapi import FastAPI, Query 02 03from event_loop import run_experiment 04 05app = FastAPI(title="Python 事件循环") 06 07@app.get("/event-loop") 08async def experiment( 09 delay_ms: int = Query(default=30, ge=5, le=100), 10) -> dict[str, object]: 11 report = await run_experiment(delay_ms) 12 print(report) 13 return report 14
01import asyncio 02 03async def run_experiment(delay_ms: int) -> dict[str, object]: 04 loop = asyncio.get_running_loop() 05 events = [] 06 completed = loop.create_future() 07 08 def finish() -> None: 09 events.append("定时回调") 10 if not completed.done(): 11 completed.set_result("回调完成") 12 13 async def worker(name: str) -> str: 14 events.append(f"{name} 开始") 15 await asyncio.sleep(0) 16 events.append(f"{name} 恢复") 17 return name 18 19 loop.call_soon(events.append, "就绪回调") 20 handle = loop.call_later(delay_ms / 1000, finish) 21 cancelled = loop.call_later(1, events.append, "不应出现") 22 cancelled.cancel() 23 try: 24 results = await asyncio.gather(worker("A"), worker("B")) 25 await completed 26 finally: 27 handle.cancel() 28 return {"running": loop.is_running(), "events": events, "results": results, 29 "timer_cancelled": cancelled.cancelled(), "loop_type": type(loop).__name__} 30
打开在线案例,点击运行,等待环境就绪,再发送默认 GET /event-loop?delay_ms=30。本篇无需密钥或外部服务。
GET /event-loop?delay_ms=30
running 和 timer_cancelled 都为 true,结果为 ["A", "B"],事件中没有 "不应出现"。观察 A、B 的开始与恢复如何交错;不要把具体回调顺序当成跨平台固定契约。
running
timer_cancelled
true
["A", "B"]
"不应出现"
调大延迟可以观察定时回调更晚出现。运行时使用已有事件循环,接口内部没有嵌套 asyncio.run;没有注册永久后台任务。
实验事件和状态每次请求独立创建。实际定时与耗时会受到运行环境影响,不能据此承诺固定调度顺序或实时精度。日志输出本次报告,可以在修改参数后对照查看。
下载项目后,在本机终端执行:
1uv run fastapi dev main.py
然后通过 http://127.0.0.1:8000/docs 发送同一请求。文章中的 asyncio.run(...) 是独立终端脚本入口;浏览器和 FastAPI 接口已经有事件循环,这里的案例直接 await 实验函数。
http://127.0.0.1:8000/docs
asyncio.run(...)
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 职责
协程能够暂停和恢复,但协程本身不知道应该在什么时候恢复,也不知道暂停期间应该运行谁。事件循环(event loop)就是负责这项工作的调度器。
假设程序中有三个任务:
事件循环不会一直守着任务 A。它会先运行已经就绪的任务 C,同时监听任务 A 和任务 B 等待的 IO。某个 IO 完成后,对应任务重新获得运行资格,事件循环再选择合适的时机恢复它。
事件循环主要负责:
call_soon()等 API 注册的普通函数事件循环不是线程池,也不是让代码自动并发的语法。通常一个事件循环运行在一个操作系统线程中,这个线程在同一时刻只执行一个 Task 或回调。任务必须运行到
await、结束或抛出异常,事件循环才有机会运行其他任务。因此,
asyncio采用的是协作式调度:任务主动在可等待的位置让出执行权,而不是由事件循环在任意一行代码上强制打断任务。2. 结构
理解事件循环之前,需要先看清它周围的几个对象:
它们之间的关系可以简化为:
协程对象包装为 Task 后进入就绪状态。事件循环运行 Task;遇到尚未完成的 await 时暂停,等待 Future 或 IO。结果完成后,Task 重新就绪,由事件循环恢复执行。
FLOW / RELATIONSHIP
协程对象
一次异步函数调用
Task
包装协程,进入就绪状态
事件循环运行 Task
推进协程执行
暂停等待
尚未完成的 await / Future / IO
Task 重新就绪
等待的结果已经完成
事件循环恢复 Task
继续执行协程
Task 是事件循环真正调度的协程执行单元。Future 更像结果占位符:结果没有准备好时,等待它的 Task 暂停;Future 完成后,会安排等待它的 Task 重新进入就绪状态。
事件循环不会不停遍历所有暂停的协程,询问它们是否完成。IO 监听器、定时器和 Future 会在条件满足时通知事件循环,把相关工作重新放回可运行的集合中。
「就绪队列」「定时器集合」和「IO 监听器」适合用来建立概念模型。不同操作系统和事件循环实现的内部数据结构可能不同,业务代码不应该依赖它们的具体实现细节。
3. 调度
一次事件循环迭代可以大致理解为以下步骤:
await后暂停,事件循环继续处理其他工作;这是便于学习的简化过程,不是要求应用开发者手写的循环。平时使用
asyncio.run(),Python 会负责驱动事件循环。下面可以观察两个 Task 如何交替执行:
通常可以观察到下面的顺序:
create_task()把两个协程包装成 Task,并安排它们运行。main()执行到await gather(...)后暂停,事件循环开始推进两个子任务。示例中的
await asyncio.sleep(0)不是真的等待时间,而是主动暂停当前 Task,让事件循环有机会运行其他就绪任务。它适合演示调度,不应该被当成修复阻塞代码的通用办法。协作式调度意味着公平性不是自动保证的。如果一个 Task 长时间计算且没有遇到
await,它会一直占用事件循环线程:虽然
calculate()使用了async def,但函数内部没有真正的等待点。它开始运行后,其他 Task 只能等它计算结束。4. IO
IO 是 Input/Output(输入/输出)的缩写。在异步服务中,它通常表示等待网络、数据库、文件或其他外部资源。socket 可以先理解为程序与网络连接交互的对象。
异步 IO 的关键不是反复询问网络请求有没有完成,而是把等待交给操作系统。
以异步 HTTP 请求为例,可以把过程理解为:
await位置暂停;底层通常依赖操作系统提供的高效 IO 机制,例如 Linux 的
epoll、macOS 的kqueue和 Windows 的 IOCP。具体实现会因平台与 Python 版本而不同,但核心目标都是让一个线程同时管理大量处于等待状态的连接。所以,异步 HTTP 通常不是「一个 HTTP 请求对应一个线程」,也不需要事件循环额外创建一个「HTTP 线程」。事件循环所在的线程负责运行 Python 回调和 Task,操作系统负责监控大量 IO 状态。
定时等待也是类似的思路:
asyncio.sleep(2)会注册定时等待并暂停当前 Task,通常不会创建一个专门的定时器线程。两秒后只表示这个 Task 具备恢复资格;如果事件循环此时正在执行其他代码,实际恢复时间可能稍晚。5. 回调
大多数业务代码只需要协程和高层 API,但事件循环也提供了调度普通回调的低层接口:
loop.call_soon()loop.call_later()loop.call_at()loop.call_soon_threadsafe()asyncio.run_coroutine_threadsafe()call_soon()返回 Handle,call_later()返回 TimerHandle。只要回调尚未执行,就可以通过它们的cancel()方法取消调度。call_later()使用相对延迟,call_at()使用与loop.time()相同的单调时钟。单调时钟只适合计算时间间隔,不应该把loop.time()当成日期时间戳。这些回调是普通同步函数。回调一旦开始运行,在返回之前会占用事件循环线程,因此回调内容也应该保持短小,不能直接执行阻塞 IO 或长时间计算。
大部分
asyncio对象都不是线程安全的。在事件循环线程之外调用call_soon()并不安全,必须使用call_soon_threadsafe();从其他线程提交协程时,则使用run_coroutine_threadsafe()。Python
asyncio没有 JavaScript 那种公开且严格对应的「宏任务队列」和「微任务队列」。call_soon()、Task 恢复、Future 完成和定时回调都遵循asyncio自己的调度规则,不应该机械套用Promise.then()与setTimeout()的优先级结论。6. 运行
普通 Python 程序应该优先使用
asyncio.run()作为异步入口:asyncio.run()会完成一整套生命周期管理:asyncio.run()不能在同一线程已经运行事件循环时再次调用。FastAPI、异步测试框架和部分交互式环境已经管理事件循环,此时应该直接await:在协程和回调内部需要取得当前事件循环时,优先使用
asyncio.get_running_loop()。旧教程经常展示get_event_loop()、new_event_loop()、run_forever()和手动close(),这些是低层控制接口,不是普通应用的首选写法。事件循环 policy 体系也已经弃用,因此不建议新项目把 policy 配置作为主线方案。事件循环不能解决同步阻塞代码。下面的接口会让同一事件循环上的其他 Task 一起等待:
优先把同步库替换为异步库。确实无法替换的短时间阻塞 IO,可以使用
asyncio.to_thread()隔离:开发阶段还可以启用调试模式,帮助发现忘记等待的协程、错误的跨线程调用和执行时间过长的回调:
调试模式会增加额外开销,适合开发和排查问题,不应在不了解成本的情况下直接作为高负载生产环境默认配置。
7. 在线实验
使用当前事件循环注册回调、取消 TimerHandle,并让两个 Task 主动让出执行权。
入口和主题代码与工作区直接共用同一份来源:
打开在线案例,点击运行,等待环境就绪,再发送默认
GET /event-loop?delay_ms=30。本篇无需密钥或外部服务。running和timer_cancelled都为true,结果为["A", "B"],事件中没有"不应出现"。观察 A、B 的开始与恢复如何交错;不要把具体回调顺序当成跨平台固定契约。调大延迟可以观察定时回调更晚出现。运行时使用已有事件循环,接口内部没有嵌套 asyncio.run;没有注册永久后台任务。
实验事件和状态每次请求独立创建。实际定时与耗时会受到运行环境影响,不能据此承诺固定调度顺序或实时精度。日志输出本次报告,可以在修改参数后对照查看。
下载项目后,在本机终端执行:
然后通过
http://127.0.0.1:8000/docs发送同一请求。文章中的asyncio.run(...)是独立终端脚本入口;浏览器和 FastAPI 接口已经有事件循环,这里的案例直接await实验函数。