外观
用了 async,接口为何仍然卡住:事件循环、Task 与取消
摘要
接口函数写了 async def,其他请求却仍然无法及时执行。本文从受控阻塞与任务取消实验出发,讲清协程怎样暂停、事件循环怎样调度,以及超时和任务组为什么依赖可靠清理,而不是只改函数声明。
验证环境: Windows x64,CPython 3.14.0 常规 GIL 构建;同一独立示例亦已在 CPython 3.13.7 运行通过。实验验证协作顺序、任务组失败和取消清理,精确调度耗时不是跨环境保证。
场景:异步接口里,一个同步调用拖住所有任务
这是教学场景。查询接口使用异步框架,处理器也声明为 async def,但内部调用一个同步客户端等待结果。在这段等待期间,同一个事件循环上的健康检查、定时器和其他请求都出现延迟。开发者检查代码,认为“既然已经 async,就应该自动并发”。 可进一步阅读IO模型epoll与事件循环:I/O就绪与事件循环不能等同完成通知。
用一个只把“我已执行”记入列表的小任务 ticker 观察循环顺序。Task是事件循环管理的协程任务;创建它以后,循环还需要执行机会才能推进它。先预测两种等待的差别:当前路径调用 time.sleep 占住循环线程,ticker要等它交出执行;换成 await asyncio.sleep,当前协程暂停,ticker才有机会先运行。本篇沿“谁获得执行→在哪一处真正挂起→谁负责恢复和收尾”追任务。async def只定义协程函数,不能把同步调用自动移到线程,也不会替等待中的资源建立退出协议。
本文主线 CPython 3.14 常规构建,示例只用标准库,TaskGroup 自 Python 3.11 提供。没有模拟完整网络服务,阻塞实验只验证调度顺序;真实 HTTP 和数据库等待的诊断链放在第 24 篇,不从一次 sleep 实验推导线上吞吐。
从普通函数到协程:调用与执行要分开
普通函数调用通常立即进入函数体并得到结果;async def 定义协程函数,调用它得到 coroutine object(协程对象,保存可暂停执行过程的对象),函数体不会因此自动完整执行。必须由等待或调度机制推进它。
awaitable(可等待对象)是可以放在 await 表达式中的对象,主要包括协程、Task 和 Future。Future 可以理解为最终结果的占位,记录完成、失败等状态;Task 则把协程交给事件循环管理,负责按依赖推进执行。不能把三者都叫“一个线程”,它们与 OS 线程不是同一执行单元。
设有两个彼此独立的操作,先保持它们各自的逻辑不变,只改组织方式:连续写两次 await,第二个通常在第一个完成后才开始;先组织为独立Task,循环才拥有可交叠推进的两份状态。await表达依赖,Task建立受调度的执行,这两步不能等同。
await 还不保证每次都发生真实调度切换。被等待对象已经完成,或者内部过程无需暂停时,当前执行可以继续。因此不能把“await 之间的代码”随意当成永远不可交错的业务事务,也不能靠插入没有真实等待的 await 保证公平性。
事件循环怎样推进多个任务
event loop(事件循环)管理可运行回调、定时器和等待中的 I/O 等信息。一个任务运行到需要暂停的等待点,登记依赖后交出执行;依赖就绪时,循环再安排它继续。这个模型让少量线程管理大量重叠等待,但没有消除底层连接、带宽和后端处理容量。
图表将在阅读到此处时加载…
如果任务调用 time.sleep,发生的是当前线程等待,而不是把一个协程定时等待登记给事件循环。它没有给同线程循环提供正常推进机会。同步文件读取、同步数据库驱动、很长的 Python 计算也可能造成类似阻塞,具体成本要靠观测判断。
异步 I/O 不代表“没有任何线程”或“没有系统调用”。不同平台的事件循环可以使用不同 OS 机制,有些封装也用线程执行特定阻塞操作。对应用最重要的边界是:调用能否在等待时让事件循环继续工作,是否支持超时与取消,以及资源限制在哪里。
最小实验:观察顺序,验证 TaskGroup 清理
保存以下代码为 docs/python/examples/21_asyncio.py。第一部分给循环提交一个 ticker,再比较阻塞等待与协作等待的执行顺序;第二部分构造一个等待任务和一个失败任务,验证任务组退出前清理发生。
python
"""Show loop blocking and structured cancellation with bounded tasks."""
import asyncio
import time
import threading
async def compare(blocking):
events = []
async def ticker():
events.append("ticker")
task = asyncio.create_task(ticker())
if blocking:
time.sleep(0.03) # Wrong: occupies the loop thread.
else:
await asyncio.sleep(0.03) # Correct: suspends this coroutine.
events.append("operation finished")
await task
return events
async def main():
wrong = await compare(True)
correct = await compare(False)
assert wrong == ["operation finished", "ticker"]
assert correct == ["ticker", "operation finished"]
print("blocking:", wrong)
print("cooperative:", correct)
ready = asyncio.Event()
cleaned = asyncio.Event()
async def worker():
try:
ready.set()
await asyncio.Event().wait()
finally:
cleaned.set() # Release actual resources here in application code.
async def fail():
await ready.wait()
raise ValueError("teaching failure")
try:
async with asyncio.TaskGroup() as group:
group.create_task(worker())
group.create_task(fail())
except* ValueError as errors:
print("group errors:", len(errors.exceptions))
assert cleaned.is_set()
print("cancelled worker cleaned:", cleaned.is_set())
cleanup_started = asyncio.Event()
async def slow_cleanup():
try:
await asyncio.Event().wait()
finally:
cleanup_started.set()
await asyncio.sleep(.02) # Cancellation cleanup itself takes time.
started = time.perf_counter()
try:
await asyncio.wait_for(slow_cleanup(), timeout=.01)
except TimeoutError:
assert cleanup_started.is_set()
print("wait_for elapsed including cleanup:", time.perf_counter()-started)
else:
raise AssertionError("timeout did not occur")
shield_release = asyncio.Event()
protected = asyncio.create_task(shield_release.wait())
outer = asyncio.shield(protected)
outer.cancel()
try:
await outer
except asyncio.CancelledError:
assert not protected.done()
finally:
shield_release.set()
await protected # Strong reference and explicit ownership of residual work.
print("shield protected task survived outer cancellation and was joined")
thread_started, thread_release, thread_done = (threading.Event() for _ in range(3))
def external_work():
thread_started.set()
try:
if not thread_release.wait(3):
raise TimeoutError("thread release deadline")
finally:
thread_done.set()
task = asyncio.create_task(asyncio.to_thread(external_work))
try:
while not thread_started.is_set():
await asyncio.sleep(0)
task.cancel()
try:
await task
except asyncio.CancelledError:
pass
assert not thread_done.is_set()
print("cancelled awaiter; underlying thread still running")
finally:
thread_release.set()
await asyncio.to_thread(thread_done.wait, 2)
assert thread_done.is_set()
queue = asyncio.Queue(maxsize=2)
observed = []
async def producer():
for value in range(6):
await queue.put(value)
assert queue.qsize() <= 2
await queue.put(None)
async def consumer():
while True:
value = await queue.get()
try:
if value is None:
return
observed.append(value)
await asyncio.sleep(0)
finally:
queue.task_done()
async with asyncio.TaskGroup() as group:
group.create_task(producer())
group.create_task(consumer())
await queue.join()
assert observed == list(range(6))
print("bounded queue drained:", observed)
if __name__ == "__main__":
asyncio.run(main())powershell
python docs/python/examples/21_asyncio.py按前面的预测核对两条事件轨迹:阻塞分支先写operation finished,交出机会后ticker才写入;协作分支先暂停,ticker运行,随后operation finished。代码断言检查顺序,不以几十毫秒的比例证明性能。TaskGroup实验则先用ready证明worker已进入等待,再让fail抛ValueError,组退出前worker的finally设置cleaned;“曾开始→被取消→已清理”三站都在,才不是把未执行误看作退出成功。
把同一个等待从阻塞式改成协作式,改变的是循环能否推进ticker,而非远端工作速度;把散落任务改成TaskGroup,改变的是失败后谁负责收束,而非数据库原子性。两组对照分别支持调度与生命周期模型。真实连接、许可和文件应在worker的finally执行退出,cleaned这里只是验证路径的标记,不能冒充已经测试了所有资源API。
ready 确保失败发生前等待任务已开始,避免把“任务根本没执行”误当成“取消时清理正常”。cleaned 是观测标志,不是业务资源;真实代码应在同样位置关闭连接、释放许可和结束临时工作。此处等待一个永远不主动完成的 Event,退出能力由任务组取消提供,整个程序仍然有界。
取消是协作协议,不是立即杀掉执行
Task 的取消请求会在适当机会向协程注入 asyncio.CancelledError,让协程沿异常路径结束。它不是强制中断任意 C 调用,也不保证在没有让出执行的长循环中立刻发生。一个一直占用循环的任务,还可能让发起取消的代码本身都迟迟得不到机会。
可靠清理通常放进 try/finally。如果显式捕获取消异常,一般应在完成清理后继续传播,不能把取消吞掉并假装任务成功。官方任务取消说明指出 TaskGroup 和 timeout 等结构化并发组件内部使用取消,吞掉它可能破坏组件行为。
CancelledError 直接继承 BaseException,普通 except Exception 不会捕获它。这种区分使很多业务错误处理无需介入取消,但 except BaseException 或裸捕获会改变行为。代码审查时,遇到“所有异常都返回默认值”的封装,要检查它是否也吞了取消及进程退出信号。
清理里可能也有异步等待。它应尽量短、明确、可以判断失败,不能为了保护资源无限等待另一个外部服务。若业务必须保留某段工作,需要显式所有者和监控,不能随意 shield 后遗忘任务。取消时是否重新收到取消、如何完成终结,需要基于组件与应用约定验证,不靠“finally 一定瞬间完成”的猜测。
TaskGroup 为什么比散落的后台任务更容易管理
structured concurrency(结构化并发)把子任务放进父级明确的生命周期范围。TaskGroup 在退出时等待任务结束;成员出现非取消异常时,通常取消其他成员,等待相关清理,再汇总异常。这样调用方可以在作用域退出后判断相关任务已经收束,而不是去全局列表猜测还有多少后台工作。
多个失败可能形成 ExceptionGroup(异常组,把多个异常按结构汇总的对象),except* 用来处理其中匹配的异常类型。它不是普通 except 的换皮:处理一个类型不等于其余异常已经消失。示例只产生一个 ValueError,所以可以明确检查组内数量,真实业务不能预设所有失败都同一种。
任务组还要处理嵌套、父任务取消和成员失败同时发生的复杂情况,细节在不同版本演进。官方 TaskGroup 文档列出父任务与成员取消、异常聚合等规则。本文实验验证基本生命周期,不声称覆盖所有取消竞态。
gather 的默认失败行为与 TaskGroup 不相同,不能把一个换成另一个后假设其他任务总会自动取消。选择 API 应先问:这些任务是同一次业务操作必须共同成功,还是相互独立、允许部分失败?再决定失败传播和结果汇总协议。
超时为什么可能超过设定秒数
timeout(超时)描述等待预算及超出后的协议,不代表外部工作瞬间被撤销。asyncio.wait_for 超时会请求取消被等待对象,并等待取消完成,因此实际结束时间可能超过名义 timeout。官方 wait_for 说明明确记录这一点。
asyncio.timeout 用上下文管理范围表示预算,内部同样使用取消,并在其作用域边界按规则转换为超时异常。捕获位置和异常传播必须按 API 契约安排,不能在作用域里随意吞掉取消。多个嵌套预算还需要统一截止时间,否则每一层都重新得到完整预算,端到端等待会不断扩大。
shield 保护内部 awaitable 不因外部等待者取消而直接取消,但外部等待者仍可能收到取消。于是调用方退出后,内部任务可能继续工作。使用时必须保留任务引用,明确谁回收结果、谁记录异常、何时最终终止。shield 不创建一个自动被监管的后台服务。
超时之后的副作用尤其要小心。数据库可能已经提交,HTTP 下游可能已经处理,只是响应没回来。取消本地协程不能撤销远端已经发生的操作。重试仍需要幂等标识、提交状态和服务端协议,第 16、24 篇会沿这个边界继续讨论。
把阻塞工作移到线程:解决一层,不解决全部
asyncio.to_thread 可以把适合的同步阻塞调用放到线程中,避免直接占用循环线程。对于不释放 GIL 的大量 Python 计算,它不是常规构建下多核加速工具;对于 I/O 等等待型调用,则可能改善循环响应。
再将同一阻塞等待移进to_thread,循环响应这项问题可以缓解,但所有权多了一层。主例先确认thread_started,再取消awaiter;thread_done仍为假,直到拥有者设置thread_release并等待收尾。这条事件证据反证“Task结束即线程结束”。线程停止需要自身协议,查询超时将同样关系迁移到数据库锁持有者:停止等待不会自动释放它。
若有原生异步客户端,通常更容易把等待、连接池和取消接进同一异步模型,但也必须查具体库版本和协议。不能因为库名字含 async,就认定所有操作都可取消、所有 DNS 与文件操作都没有线程,更不能省略独立连接和超时限制。
有界并发与背压:Task 也会占内存
异步任务通常比 OS 线程轻,但仍保存参数、协程状态、回调和等待依赖。一次为一百万记录创建 Task,再给每个任务内部加 Semaphore,只限制同时操作后端的数量,却已经分配了一百万份任务状态。内存与等待时间仍可能失控。
更可靠的组织是有界生产、有限消费者和明确退出标识。队列容量不足时,生产协程等待,背压沿链路传播;消费者失败时,任务组结束其他成员,避免生产者永久等待无人处理的队列。结束协议需要区分正常完成、取消和异常,不能只在成功路径发结束标志。
连接池、Semaphore 与服务总容量也不等价。十个进程各限制一百并发,总下游压力仍可能是一千;每个请求又可产生多次下游调用。容量应该按部署拓扑和资源链计算,异步模型没有替你定义全局预算。
线上观察可以记录事件循环延迟,即定时回调计划时间与实际运行时间之间的差;同时看 Task 数量、队列长度、连接等待和端到端延迟。循环延迟高支持循环被占用的假设,但原因可能是 CPU 计算、阻塞调用、回调风暴或采集自身开销,需要栈与热点证据区分。
一个 await 点怎样影响共享状态
两个 Task 通常在同一事件循环线程中交替运行,不等于不会发生业务竞争。任务 A 检查库存后 await 外部确认,任务 B 在这段等待中修改库存;A 恢复时,原检查前提已经过期。即使没有两个 Python 指令真实同时执行,交错仍足以破坏跨等待点的不变量。
因此同步应该围绕业务关系。异步锁允许等待者挂起,而普通线程锁可能阻塞循环;但锁内执行长外部请求同样会串行化业务并扩大等待。若需要释放锁进行 I/O,再回来修改,应使用版本检查、状态预留或其他明确协议,保证旧前提失效时能够恢复,而不是盲目继续。
一个锁还可能形成逻辑死锁:任务持锁 await 另一个必须获取同锁才能完成的任务。事件循环依然可以运行其他工作,所以表现可能不是整个进程挂住,而是某个请求永久不结束。诊断要看 Task 依赖与资源所有者,不能因为循环健康检查正常就排除等待环。
从线程进入事件循环:必须走正确的交接入口
asyncio 的大部分对象不以任意跨线程访问为使用前提。如果后台线程需要通知循环,应使用文档规定的线程安全调度入口,再由循环线程更新对应状态。直接从线程修改 asyncio 队列、Future 或任务状态,可能没有正确唤醒和同步关系。
同样,普通线程锁保护的状态与 asyncio Lock 保护的状态不天然属于同一协议。混用时需要明确谁执行、谁等待、是否阻塞循环以及谁拥有释放责任。迁移同步程序到异步程序,最难的往往不是增加 await,而是重新定义交接点和资源生命期。
eager 执行与顺序假设:创建任务不总是延迟到下一轮
某些 asyncio 配置支持 eager execution(立即执行),任务创建时就开始推进协程,直到真正阻塞才交给循环后续调度。官方任务文档列出相应工厂与版本演进。采用此模式时,代码若假设 create_task 后的初始化一定先于任务体,会出现行为变化。
本实验使用普通 asyncio.run 与默认任务设置,没有安装 eager 工厂,也没有通过版本号推断所有框架的任务启动顺序。工程代码应在创建任务前准备好它需要的状态,或者用显式事件建立启动协议,避免依赖一个偶然的下一轮调度时机。
请求断开后,谁拥有剩下的任务
框架可能取消处理器,也可能按协议继续某些工作,具体要看版本和服务器行为。处理器里创建的无主任务不一定随请求一起结束;若任务还保存请求数据、连接和上下文,就会延长保留。应明确哪些工作属于请求,哪些属于服务后台,以及各自的退出监控。
任务引用也影响可靠性。官方文档提醒保存需要持续管理的任务引用,不能把创建动作当成永久监管。保存之后还要消费异常并在服务停止时收束,不能只是加入全局集合永远不移除。结构化生命周期让管理关系显式;独立后台任务则需要等价的明确所有者。
把调度问题做成可反证的实验
若怀疑某函数阻塞循环,保持相同输入,在循环上安排一个带计划时间的轻量回调,再记录函数运行期间回调是否被延迟。接着只改变阻塞调用方式,观察回调恢复是否与函数变化一致。这个实验验证循环响应,不直接评价远端服务容量,也不保证移入线程后底层资源已经可取消。
若怀疑任务取消失效,先确保任务已经进入目标等待,再发取消请求,检查异常和清理是否收束。没有启动同步的测试可能取消一个根本没执行的任务,得到“很快结束”,却完全没覆盖资源关闭。本文用ready事件建立前提,就是把取消发生的位置变成明确条件。
容易踩的坑与面试追问
第一坑是创建协程却既不 await 也不调度,函数体不会按预期运行。第二坑是反复在框架已运行的事件循环里调用 asyncio.run;应用应使用现有循环生命周期,不要嵌套建立互相冲突的运行器。
第三坑是清理时吞掉取消,或者把所有后台任务 shield 后没有所有者。第四坑是把 Task 数量当成无成本并发,只限制执行不限制生产。第五坑是认为换 async def 就完成迁移,遗漏同步客户端与计算热点。
面试问“协程和线程有什么差别”,回答执行状态、调度者、共享环境与等待协议,不只说轻量。问“await 就会切换吗”,指出就绪状态与真实挂起条件。问“Task.cancel 后是否一定立刻结束”,解释协作取消、阻塞路径和清理。问“TaskGroup 为什么好用”,从生命周期和失败收束回答,而不是只背类名。
可运行边界:取消等待者以后,线程和队列怎样退出
wait_for对照让被取消协程在 finally 再 await 0.02 秒清理,并打印包含清理的完整经过时间;断言检查清理确实开始,不用严格毫秒阈值假装调度稳定。另一个 shield 对照取消外层 Future,确认被保护 Task 尚未完成,最后由持有强引用的拥有者释放并 await 它。这两条分别检验“名义等待预算不是强制工作结束时刻”和“保护取消传播不会自动提供剩余任务的资源所有者”。
线程边界实验以三个Event 分别标记开始、释放和完成。to_thread 已进入函数后,取消其 awaiter 并收到 CancelledError,此时完成标记仍未出现。finally 显式释放线程函数,最后验证完成。证据依赖事件关系而不是猜测一次 sleep 的调度顺序;它直接反证“取消 Task 等于强杀线程”。线程内部异常仍需由拥有者汇总;示例的释放超时是兜底,不应作为业务终止协议。
另一个队列实验创建容量为 2 的 Queue,仅一个生产者和一个消费者在 TaskGroup 内。每次 put 后检查容量,消费者在 finally 调用 task_done,None 是演示专用终止消息,最终验证六项顺序和 join 完成。生产者在满队列处 await,所以上游不能无限越过边界。它没有覆盖持久消息或多消费者关闭;多消费者需要每个消费者的终止协议,生产异常也要让 TaskGroup 取消其他任务,不能在组外无限等 join。
与 Java FutureTask 取消比较结果句柄、执行结束和资源清理三层,Java interrupt 与 Python 协作异常机制不同。线程共享状态解释底层线程为什么需要自身停止协议;查询超时进一步演示停止等待以后锁持有者仍存在。
能力任务:将消费者改为处理第三项时失败,记录生产者是否被取消、哪些任务已完成、哪些还留队列。验收要求所有 Task 被拥有与等待,异常传播到入口,失败路径不调用永远等不到的 join;不能以丢弃队列假装所有业务成功。
一句话总结:异步并发来自可靠的让出执行、等待管理与生命周期收束。
async def产生协程,Task把协程交给事件循环调度。- 阻塞调用和长计算会占住循环,超时与取消也需要获得执行机会。
- 用任务组、可靠清理和有界生产管理并发,避免无人负责的后台工作。
继续阅读:生成器、HTTP 与 ASGI、超时排障实战。上一篇:多进程;下一篇:性能测量。