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 从来不是新知识,只是一个需要换掉旧直觉的旧知识。

posted @ 2026-10-19 21:37  汤姆百宝箱  阅读(34)  评论(0)    收藏  举报