asyncio:我以为它让函数跑得更快,其实它只让等待不再空转
asyncio 是我技术栈里学得最反复的一个东西——不是难在语法,而是难在每学一遍都发现上一遍的理解是错的。
第一次学,我以为 async 的意思是“并行”,于是给一个纯计算函数加上 async def,纳闷为什么速度没有任何变化。第二次学,我写出了 await 加 time.sleep() 的代码,奇怪为什么“异步”反而把整个程序冻住了。第三次学,我在一个写了 asyncio.gather 的脚本里收获满满的 RuntimeWarning: coroutine was never awaited,对着警告抓了一晚上头。
直到后来才想明白,asyncio 的所有误区共享同一个根源:用“多线程”的直觉去理解“单线程调度”。这篇笔记的目标就是把两种直觉彻底分开,用一套统一的模型解释所有现象。
一、先回答那个最根本的问题:asyncio 到底快在哪
先立一个容易推翻的直觉:asyncio 不会让任何单个操作变快。发一个 HTTP 请求要 2 秒,用 asyncio 还是 2 秒。
asyncio 赚的是另一笔钱——等待时间的复用。同步代码在等服务器响应时,整个程序停摆干等;asyncio 在等一个响应的空档里,让 CPU 去发下一个、再下一个请求。
关键分水岭在这里:I/O 密集 vs CPU 密集。
- I/O 密集(等网络、等数据库、等磁盘):asyncio 的主场。10 个请求同步跑约 20 秒,
gather并发跑约 2 秒——总耗时逼近最慢那一个,而非全部之和 - CPU 密集(解析、计算、图像处理):asyncio 无能为力。协程不会主动抢占 CPU,一个死循环
while True: pass能把整个事件循环“锁死”
记住这个分水岭,能省掉一半无效优化。
二、三个对象,一个心脏:拆解心智模型
asyncio 的材料只有三种:协程、Task、事件循环。其中事件循环是心脏。
对象一:协程——一张没有开火的菜谱。 async def 定义的是“协程函数”,调用它不会执行任何代码,只返回一个协程对象——一段被暂停、还没有开动的计算:
async def fetch():
print("开始执行")
coro = fetch() # 什么都不会打印!
print(coro) # <coroutine object fetch at 0x...>
这行代码是新手 RuntimeWarning 的直接来源:协程是惰性的,没人驱动它就永远不动。
对象二:事件循环——只有一个厨师的厨房。 asyncio 全程单线程。一个厨师(CPU),一口灶(事件循环),桌上摆着 N 张菜谱(协程)。厨师的工作方式:拿起一张菜谱做到某个“等水开”的步骤,把菜谱放回桌上、去拿下一张;水开了再回来继续。没有第二个厨师、没有分身——只是一个人永不闲着。
对象三:await——让路牌。 await 不等于“等待”,它做两件事:执行一个 awaitable,并在等待期间把控制权交还给事件循环,让循环去跑别的就绪协程。这句话有一个精确的推论,也是第一节所有误区的解药:
await让出的是“事件循环内的控制权”,不是“CPU 给操作系统”。
同步调用time.sleep(2)时线程被操作系统挂起,事件循环整个冻住;await asyncio.sleep(2)时协程告诉循环“我要歇 2 秒,你去忙别的”——这就是 async 代码里绝不能混同步阻塞调用的原因。
三、最坑的一课:为什么“我没用 gather 就没有并发”
这是中文社区讨论里被反复问、也反复答错的问题,值得单独一节。
先看让无数人困惑的现象。同一个文件里,两段代码都在“await”,行为却完全不同:
# 写法 A:顺序 await —— 看起来 async 了,实际是串行
async def main():
await task_a() # 跑完 A 的全部,才轮到 B
await task_b() # 总耗时 = A + B
# 写法 B:gather —— 真正的并发
async def main():
results = await asyncio.gather(task_a(), task_b())
# 总耗时 ≈ max(A, B)
写法 A 慢的根源不是语法,是“同一时刻事件循环里只有一张活跃菜谱”:A 没跑完,B 根本没被登记进循环。await 的让路机制只对“已经在循环里的菜谱”生效——你连桌子都没上,让什么路。
写法 B 里 gather 做的事:把两张菜谱同时拍上桌,然后等它们全部完成。从此任何一张卡在 I/O 上,厨师立刻切到另一张。
补一个经常被忽略的细节:gather 的参数如果是裸协程对象,它会自动把它们包成 Task 并调度——所以 gather(coro_a(), coro_b()) 本身就触发了并发,不需要也不必先 create_task 再传给 gather(那样反而引入 Task 生命周期管理的坑)。
四、经典翻车现场:三个代码对比实验
模型讲完,用三个实验把直觉焊死。三个实验可以自己跑一遍,每个耗时都能直接验证模型。
实验一:time.sleep 毒害整个事件循环
import asyncio, time
async def bad_task(name, delay):
time.sleep(delay) # 同步阻塞!
return name
async def main():
start = time.time()
await asyncio.gather(bad_task("A", 2), bad_task("B", 2))
print(f"耗时 {time.time() - start:.1f}s") # 4.0s —— 串行!
结果 4 秒,不是 2 秒。 time.sleep 挂起的是整个线程,事件循环无法切到 B。把 time.sleep 换成 await asyncio.sleep,立即变 2 秒。一行之差,天壤之别——这是 asyncio 第一大坑。
实验二:requests 混进 async 代码,并发归零
# 错误示范:requests 是同步库
async def fetch(url):
return requests.get(url).text # 阻塞循环!
# 正确:用 aiohttp 或 httpx
async def fetch(session, url):
async with session.get(url) as resp:
return await resp.text()
库本身必须是为 asyncio 设计的——requests 的每一次 get 都会冻结循环,写多少 gather 都救不回来。异步是“传染性”的:一处 await,整条调用链都得 async。
实验三:忘了 await,协程根本没跑
async def main():
fetch("http://api.com") # 没有 await!
print("完成")
# 警告:RuntimeWarning: coroutine 'fetch' was never awaited
回到第二节的对象模型:协程是惰性菜谱,不 await / 不调度,它一个字节都不会执行。这类 bug 的恶心之处在于:不报错、只警告,程序看似正常跑完,实际功能全部静默失效。
六、真实战果:同一份爬虫,两种写法的差距
用一个真实数字收尾。抓取 100 个页面,同样的解析逻辑、同样的机器:
| Requests 同步 | aiohttp + gather | |
|---|---|---|
| 耗时 | ~50 秒 | ~5 秒 |
| 原理 | 逐个等待响应之和 | 逼近最慢一个响应的耗时 |
| asyncio 没有让任何一个请求变快——它只是让 99 个请求的等待时间被填满了。这就是全部秘密。 | ||
| 顺手给一个可以直接抄的完整模板(爬虫类任务通用): |
import asyncio
import aiohttp
async def fetch(session, url, semaphore):
async with semaphore: # 并发上限,防限流
async with session.get(url) as resp:
return await resp.text()
async def main(urls):
semaphore = asyncio.Semaphore(10) # 同时最多 10 个
timeout = aiohttp.ClientTimeout(total=30)
conn = aiohttp.TCPConnector(limit=20, limit_per_host=10)
async with aiohttp.ClientSession(timeout=timeout, connector=conn) as session:
tasks = [fetch(session, url, semaphore) for url in urls]
return await asyncio.gather(*tasks)
if __name__ == "__main__":
urls = [f"https://example.com/page/{i}" for i in range(100)]
results = asyncio.run(main(urls))
三个细节都来自实战踩坑:Semaphore 限并发防封(无限并发是“异步自杀式攻击”)、ClientSession 全局复用(不共享 session 等于每次重新握手,性能反而倒退)、asyncio.run 只在入口出现一次。
结语
回头看,asyncio 的每个“反直觉”其实都在陈述同一件事:
asyncio 是单线程内的 I/O 并发调度系统——它不创造速度,只消灭空等。
这句话往回推:因为单线程,所以time.sleep冻结全局、CPU 密集任务无解;因为靠调度,所以不进事件循环的协程是死菜谱、顺序 await 等于串行;因为只赚等待的钱,所以 I/O 密集是主场、纯计算分文不取。所有现象都是这一个模型的推论——asyncio 从来不是新知识,只是一个需要换掉旧直觉的旧知识。

浙公网安备 33010602011771号