一个异步爬虫写完上线,日志里偶尔出现一行警告,功能看起来正常,但抓取量总比预期少。警告原文是:
RuntimeWarning: coroutine 'fetch' was never awaited
代码里调用了 fetch(url),但没有写 await。协程函数被调用时不会执行函数体,只会创建一个协程对象;不 await 它、不把它包装成任务,这个对象最后被垃圾回收,函数体一次都没跑。没有异常,没有返回值,只有一行容易被忽略的警告。
另一个更隐蔽的问题是「异步代码里混进同步阻塞」。有人在协程里调了 time.sleep(1) 或者同步的 HTTP 客户端,整个事件循环停住一秒,所有并发请求一起等。异步的并发是「单线程内的切换」,只要有一处不让出控制权,其他任务全部被堵住。这篇从协程和事件循环讲起,把并发、取消、超时和阻塞这几个关键点说清。
协程、任务与事件循环
async def 定义的是协程函数。调用它返回一个协程对象,函数体不会立刻执行。协程对象要交给事件循环,由循环在合适的时机推进;推进的方式就是 await。遇到 await,协程把控制权交回事件循环,循环去跑别的任务,等被等待的操作完成,再回来继续。
事件循环是单线程的调度器,内部维护「就绪任务」和「等待中的 I/O」。它依赖操作系统的 I/O 多路复用机制(Linux 上是 epoll,Windows 上是 IOCP 或 select 系列),一次等待多个文件描述符,谁就绪就唤醒谁。这套机制的原理在I/O 模型里有更完整的说明,这里只需要记住:异步省的是「等待时的线程资源」,不是「计算时间」。
协程对象和任务不是一回事。协程是「一段可以暂停的执行」,任务(asyncio.Task)是「已经被事件循环接管、正在排队或运行的协程」。直接 await coro 是当前协程等它;create_task(coro) 是把它交给循环独立调度,当前协程可以继续做别的事。
入口用 asyncio.run(main()),它创建事件循环、运行主协程、最后关闭循环。一个线程只能有一个运行中的循环,在协程里再调 asyncio.run 会报 RuntimeError: asyncio.run() cannot be called from a running event loop。我实测过,报错信息很明确,但很多人是在库函数里踩到的:某个同步封装内部又调了 run。
也正因为如此,同步函数里不能直接 await。需要从同步代码调用异步函数时,要么把上层也改成异步,要么用 asyncio.run 在独立入口执行,要么用 asyncio.run_coroutine_threadsafe 把协程交给另一个线程的循环。三种方式各有适用场景,混着用会让「循环到底在哪个线程跑」变成一笔糊涂账。
并发:gather、create_task 与 TaskGroup
顺序 await 是串行。三个各睡 0.5 秒的任务顺序执行,实测总耗时 1.531 秒;用 asyncio.gather 同时跑,总耗时 0.506 秒。差别不是协程更快,而是等待重叠了。
async def work(i, delay=0.5):
await asyncio.sleep(delay)
return i
results = await asyncio.gather(*(work(i) for i in range(3)))
print(results)
输出 [0, 1, 2],顺序按传入顺序,不受完成顺序影响。gather 默认「一个任务抛异常就立刻向上抛,其他任务继续跑但不被等待」;传 return_exceptions=True 会把异常当成结果返回,适合「一批任务里允许部分失败」的场景,比如批量抓取时记录失败的 URL。
create_task 适合「先启动、后面再等」。启动后当前协程继续执行,任务在后台推进;需要结果时再 await task。注意创建任务后要保留引用,否则任务对象可能被回收,运行中的任务被取消。事件循环只持有弱引用,这是官方文档专门提醒过的坑。
TaskGroup 是较新版本提供的结构化并发写法:一组任务在同一个 async with 块里启动,块结束时自动等待全部完成;任何一个任务失败,其余任务会被取消,异常以 ExceptionGroup 形式抛出。它比 gather 更容易保证「不会漏掉后台任务」,新代码可以优先考虑。
并发数量要有上限。一次创建一万个任务去请求同一个站点,事件循环能撑住,但下游可能被打挂,本机的连接和内存也会吃紧。用 asyncio.Semaphore 限制同时进行的数量,是异步里最基本的限流手段。
任务之间传数据用 asyncio.Queue。它和线程队列的接口很像,put 和 get 都是协程,队列满时 put 会等待,天然形成背压。不要用普通列表在任务之间共享数据,列表没有等待语义,生产快、消费慢时会无限增长。队列加上有界容量,是异步流水线里最省心的组合。
取消:不是杀死,是请求停下
task.cancel() 不会立刻终止任务,而是在任务下一次 await 的位置抛入 CancelledError。任务可以捕获它做清理,然后选择继续抛出(真正取消)或吞掉(继续运行)。如果任务正卡在不支持取消的同步调用里,取消要等那个调用返回才生效。
async def forever():
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
print("inner cleanup")
raise
task = asyncio.create_task(forever())
await asyncio.sleep(0.2)
task.cancel()
try:
await task
except asyncio.CancelledError:
print("cancelled", task.cancelled())
实际输出 inner cleanup,然后 cancelled True。CancelledError 在较新版本里继承 BaseException,不是 Exception,所以 except Exception 不会误吞它。这是有意的设计:取消是控制流,不是普通错误。清理逻辑要放在 finally 里,确保无论正常结束还是取消都会执行。
不要吞掉 CancelledError 除非你非常清楚后果。捕获后不重新抛出,等于告诉调度方「这个任务取消失败」,它可能继续跑很久,调用方却在等一个永远不会结束的取消。确实需要「取消时多做一些事」的,用 asyncio.shield 保护关键段,或者把清理逻辑写进 finally,不要靠吞异常。
异步资源也要显式关闭。异步文件、HTTP 会话、连接池通常提供 async with 或 aclose(),退出前必须调用。with 和 async with 看起来一样,但后者在退出时可能 await 清理逻辑;用错会在类型检查或运行时暴露。一个连接没关,短期看不出问题,长期就是句柄泄漏、连接池耗尽。
程序退出时也要处理取消。事件循环关闭前,未完成的任务会被取消,如果它们不响应取消,关闭会卡住或报警告。长生命周期的后台任务要有明确的停止信号,收到后走完清理再退出,而不是依赖进程被杀。
超时:等待必须有上限
asyncio.wait_for(coro, timeout) 在超时后取消被等待的协程,并抛 TimeoutError。我实测等一个 5 秒的协程、设 0.5 秒超时,抛出的异常是 TimeoutError(),耗时约 0.5 秒。较新的写法是 async with asyncio.timeout(0.3):,块内任何 await 超时都会抛同样的异常,作用范围更直观。
wait_for 取消的是「被等待的协程」,如果那个协程内部还有自己创建的任务,需要它自己在取消时清理。另一种情况是「超时了但底层操作还在跑」,比如某些同步库不响应取消,这时只能记录并让它在后台结束,不能假设它已经停了。
超时要分层设置:连接超时、单次请求超时、整个批次的总超时。只设一个很大的总超时,问题会被掩盖到最后;只设很短的连接超时,慢但正常的请求会被误杀。把每一层的预期写进配置,日志里记录实际耗时,才能判断超时值是否合理。
超时和重试要一起设计。一次超时后立刻重试,赶上对端正忙,只会雪上加霜;退避加上随机抖动,能避免大量客户端在同一时刻重试。总预算也要有:单次 2 秒、最多 3 次、整批 6 秒,超过就直接向上报错。没有总预算的重试,会把一个 2 秒的请求拖成半小时。
TimeoutError 和业务异常要分开处理,不要一个 except Exception 把超时当成普通失败重试。对已经超时的请求反复重试,会让下游压力成倍放大。阻塞:异步里最贵的错误
异步的并发靠「快速让出控制权」。任何不让出的操作都会独占事件循环。最典型的是 time.sleep、同步 HTTP 客户端、同步数据库驱动、大量 CPU 计算。我做过一个实验:创建一个每 0.1 秒打印一次的定时任务,然后主协程里 time.sleep(0.5),实际输出是:
tick 0.504
tick 0.611
tick 0.712
第一次 tick 迟到了 0.5 秒,正好等于阻塞时间。事件循环在这 0.5 秒里完全停摆,所有任务一起等。换成 await asyncio.sleep(0.5),第一次 tick 会在 0.1 秒左右出现,因为等待期间循环可以去跑别的任务。
线上可以用「循环延迟」监控来发现这类问题:启动一个每 0.1 秒醒来的任务,记录实际间隔和预期间隔的差,差值持续偏大就说明事件循环被阻塞了。这个指标比单看接口耗时更早暴露问题,因为一个慢同步调用会拖慢所有并发请求,而单条日志只会显示「都变慢了」,找不到源头。
处理同步阻塞有两个工具:asyncio.to_thread(func, ...) 把同步函数丢到线程池执行,loop.run_in_executor(...) 更底层一些。它们适合「无法改造成异步」的库,比如老的文件 API、同步 SDK。代价是线程池有上限,默认大小通常和 CPU 核数相关,大量阻塞调用仍然会把线程池排满。
纯 CPU 计算不要放进事件循环。to_thread 也救不了 GIL 下的计算密集型任务,应该用多进程,或者把计算拆小、用 await asyncio.sleep(0) 主动让出(这只是缓解,不解决并行)。判断标准还是那个:等 I/O 用异步,算 CPU 用多进程。
异步库和同步库不要混着用。一个请求链路里只要有一层是同步阻塞,整条链路的并发能力就被它限制。改造时从最外层开始,确认每一层都真的支持 await,别只看函数名写着 async 就以为它是非阻塞的。
异常:没人取的结果会沉默
用 create_task 启动的任务,如果抛了异常而没人 await 它,异常不会立刻冒出来,任务结束时事件循环打印一行警告:
Task exception was never retrieved
future: <Task finished name='Task-7' ... exception=ValueError('boom-async')>
这行警告只出现一次,很容易被日志淹没。之后程序继续跑,你以为任务成功了,实际什么都没做。解决办法是:每个创建的任务都要有明确的等待点,或者加 done_callback 记录结果;用 TaskGroup 或 gather 让异常在统一的位置抛出。
gather 的异常语义前面说过:默认第一个异常向上抛,其他任务不被等待。这可能导致「异常抛出了,但还有任务在后台跑」。要等全部结束再处理异常,用 return_exceptions=True,然后自己检查每个结果是不是异常对象。
取消和异常要分开。取消抛 CancelledError,业务失败抛普通异常,超时抛 TimeoutError。在日志里把这三类区分开,排查时才知道是「用户主动停」还是「程序出错」还是「等太久」。混在一起记成「任务失败」,等于丢掉了最重要的信息。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
coroutine was never awaited | 调用了协程函数但没 await 或没包成任务 | 检查调用点是否漏了 await,确认返回值被使用 |
| 所有请求一起变慢 | 某处同步阻塞占住了事件循环 | 搜 time.sleep、同步 IO,改成异步或 to_thread |
顺序 await 很慢 | 等待没有重叠,实际是串行 | 改成 gather、create_task 或 TaskGroup |
asyncio.run() cannot be called from a running event loop | 协程内部又调用了 run | 去掉内层 run,统一由入口创建循环 |
| 取消后任务还在跑 | 任务吞掉了 CancelledError 或卡在不可取消的调用 | 检查 except 分支,确保重新抛出 |
| 超时了但下游还在处理 | 被等待的协程没响应取消,底层操作仍在跑 | 确认底层库支持取消,或接受它自然结束 |
Task exception was never retrieved | 任务失败但没人 await 它 | 给每个任务加等待点或完成回调 |
| 并发一高内存就涨 | 任务数量没有上限,全部堆在内存里 | 用 Semaphore 限流,分批处理 |
| 异步函数名但性能没提升 | 函数内部仍是同步调用,只是套了 async | 逐层确认每个 IO 都真的 await 到底层 |
边界与代价
异步的第一个代价是「传染性」。一个函数改成 async,所有调用它的地方都要改,整条链路要一起异步化。链路中间只要有一个同步库,改造就卡住。这就是为什么异步适合从项目一开始就用,后期改造往往要动很多层。
第二个代价是调试。异常栈里会出现事件循环和任务调度的帧,报错位置不如同步代码直观;断点会暂停整个循环,其他任务一起停。日志要带任务标识和请求 ID,否则并发请求的日志会完全交错,根本对不上。
第三个代价是「并发不等于加速」。异步只在等待时切换,CPU 计算仍然要占满那一个线程。把计算密集型任务塞进协程,只会让其他任务等得更久。算和等要分开处理,这是异步设计的基本功。
第四个代价是生态兼容。很多成熟库仍是同步的,异步版本可能功能少、维护弱。选型时要确认目标库的异步支持是否完整,不要为了「全异步」用一个不成熟的实现。混合方案里,to_thread 是现实可用的折中,但要知道它的线程池上限。
最后是取消语义的复杂度。写代码时要考虑「任务在任意 await 点被取消」的情况,资源要能清理,状态要能回滚。这比同步代码多一层心智负担,但也是异步能安全处理大量并发的原因。
小结
async def 返回协程对象,必须 await 或交给事件循环才会执行;事件循环单线程调度,遇到 await 切换任务;并发用 gather、create_task 或 TaskGroup,注意任务引用和数量上限;取消是抛 CancelledError,清理写进 finally,不要吞掉;超时用 wait_for 或 asyncio.timeout,按层设置;同步阻塞会拖住整个循环,用 to_thread 或换成异步库;任务异常没人取会沉默,必须有等待点或回调。
Python 这八篇走完了语法、特性、标准库、文件、网络、多进程、多线程和异步。它们不是八个孤立的知识点,而是一条线:先会写,再会用,然后知道什么时候该并行、什么时候该等待、什么时候该让出控制权。真正的分水岭不是记住 API,而是遇到性能问题时能判断瓶颈在 CPU、在 I/O、还是在锁。
当天可以自己验证的练习:
- 写三个各
sleep(0.5)的协程,先用顺序await跑,再用gather跑,记录两个耗时。 - 故意调用协程函数不写
await,运行并观察RuntimeWarning的完整内容。 - 在协程里调用
time.sleep(0.5),同时跑一个每 0.1 秒打印的定时任务,记录 tick 的时间间隔。 - 用
wait_for给一个 5 秒任务设 0.5 秒超时,打印异常类型和实际耗时。 - 创建一个会抛异常的任务但不
await,运行后观察Task exception was never retrieved,再改成gather让异常正常抛出。
如果想继续往下走,可以回到第一篇把基础再夯实,或者去看学习路线里按先修顺序编排的路径。语言只是工具,真正的能力是在具体项目里判断「该用哪种并发、该在哪里加锁、该在什么时候放弃优化」。