Python 异步编程翻车实录:asyncio 那些坑,我替你踩了一遍

2026-11-15 12 0

写 Python 异步代码那天,我以为自己很懂 async/await。直到生产环境里,一个 asyncio.gather 把整个服务的连接池抽干,告警短信像机关枪一样响。

那天之后我明白:asyncio 不是「异步版多线程」,它是一套完全不同的并发心智模型。用错一次,代码不会报错,只会在你喝完一杯咖啡后安静爆炸。

这篇不讲语法糖,直接聊生产环境踩过的坑,以及一套我现在敢用的写法。

一、单线程凭什么能并发

核心秘密只有一个:事件循环。它本质上是个单线程调度器,所有协程都跑在这一个线程上,靠 await 让出控制权。听起来很美好,直到你写下:

async def fetch(url):
    return requests.get(url).text   # 阻塞整个事件循环

这一行在返回之前,事件循环里其他协程全在原地罚站。铁律只有一句:

任何 await 的位置都必须非阻塞。会卡住线程的调用,要么丢进 run_in_executor(),要么换异步版本。

判断方法很朴素:这个函数执行时会不会「傻等」?会,就别直接 await。最常见的翻车点:

  • requests / urllib → 换 httpx.AsyncClient 或 aiohttp
  • time.sleep() → 换 await asyncio.sleep()
  • open().read() → 换 aiofiles 或线程池
  • pymysql / psycopg2 → 换 aiomysql / asyncpg

二、并发不是越多越好

这段代码人畜无害,甚至有点优雅:

results = await asyncio.gather(
    *[fetch(url) for url in url_list]
)

如果 url_list 有 10000 个 URL,你会同时发起 10000 个请求。对方服务器把你拉黑,文件描述符瞬间打满,内存也被一次性创建的 Task 撑爆。我就是这么把下游打成 503,然后收到一句「你们这个 IP 先封一下」,非常没有感情。

正确姿势是加信号量限流:

sem = asyncio.Semaphore(20)   # 最多 20 并发

async def guarded(url):
    async with sem:
        return await fetch(url)

results = await asyncio.gather(
    *[guarded(url) for url in url_list],
    return_exceptions=True
)

三个关键点:

  1. 信号量是背压机制,不是装饰品,上限按下游真实承载能力来。
  2. 必须有超时。asyncio.wait_for(coro, timeout=10),每个 await 都套一层。不设超时的协程就是定时炸弹。
  3. 必须能容错。默认 gather 遇第一个异常就整体失败,前面成功的全白干;用 return_exceptions=True 逐个判断结果。

我现在的规矩:批量并发默认「信号量 + 超时 + 收集异常」三件套,少一个都视为未完成代码。

三、取消才是异步的精髓

同步代码只有「成功」和「抛异常」两种结局,异步多了一种:被取消。而 asyncio.CancelledError 继承自 BaseException,不是 Exception。

这意味着一个写太宽的 except Exception 会把它吞掉,然后协程拒绝死亡,表现为「服务关不掉」「重启卡住」。

# 错误:CancelledError 被吞
try:
    await do_work()
except Exception:
    log.error("failed")

# 正确:显式放行取消
try:
    await do_work()
except asyncio.CancelledError:
    raise                    # 必须重新抛出
except Exception:
    log.error("failed")

这条我写在团队规范第一页,因为踩过太疼:优雅关闭时任务不退出,30 秒后被 SIGKILL,下次启动端口没释放直接 CrashLoop。

结构化并发:TaskGroup(Python 3.11+)

它做三件事:自动等待全部任务、任意一个失败立刻取消其余任务、把所有异常汇总成 ExceptionGroup 抛出。

async with asyncio.TaskGroup() as tg:
    for url in url_list:
        tg.create_task(guarded(url))

注意差异:gather 遇异常会丢弃结果但不取消其他任务;TaskGroup 会取消兄弟任务。前者适合「尽最大努力拿结果」,后者适合「全有或全无」,选错就会拿到一堆半成品数据。

四、共享状态别硬扛

单线程看着没有数据竞争,但只要中间夹一个 await,逻辑就会被打断,「读到一半再改」都可能出事。反过来,两段没有 await 的同步代码在单线程里天然原子,这点可以放心用。

我的做法:不可变数据 + 局部变量,最后一次性提交;确实需要共享可变状态,就用 asyncio.Lock 明确保护,别指望运气。

lock = asyncio.Lock()
async with lock:
    shared_state[key] = await compute(key)

五、那些「看起来很 asyncio」的陷阱

  • 阻塞伪装成异步:日志写文件、模板渲染、加密、图像处理都会卡住事件循环,丢给 run_in_executor 或进程池。
  • 忘了 await:coroutine was never awaited 警告常被直接过滤掉,等于把安全带剪了。开 PYTHONASYNCIODEBUG=1 让它变异常。
  • 忘了建事件循环:库代码里直接 asyncio.run(),在已有循环的上下文会报错。
  • 两种原语混用:TaskGroup 和 gather 混起来,异常语义会变得极难推理。我的规矩:一个函数只出现一种并发原语。

六、可以直接抄的模板

async def fetch_all(urls, concurrency=20, timeout=10):
    sem = asyncio.Semaphore(concurrency)
    limits = httpx.Limits(max_connections=concurrency)

    async with httpx.AsyncClient(limits=limits) as client:
        async def guarded(url):
            async with sem:
                try:
                    return await asyncio.wait_for(
                        fetch_one(client, url, timeout), timeout=timeout + 2
                    )
                except asyncio.CancelledError:
                    raise
                except Exception as e:
                    logger.warning("fetch failed: %s %s", url, e)
                    return None

        async with asyncio.TaskGroup() as tg:
            tasks = [tg.create_task(guarded(u)) for u in urls]

    return [r for r in (t.result() for t in tasks) if r is not None]

httpx.Limits 和信号量是两层不同的保护:信号量管并发任务数,连接池管 TCP 连接数。少配一个,就会被网关默认的 100 连接上限打脸。

七、怎么验证写对了

  1. 用 pytest-asyncio 模拟慢响应和异常响应,断言超时、异常收集、并发上限都符合预期。
  2. 用周期性心跳 Task 监控事件循环是否被卡;心跳间隔从 10ms 飙到 500ms,说明混进同步阻塞代码了。
  3. 压测看 P99 和连接数。很多团队以为上了 asyncio 就变快,其实只是把「一个请求慢」变成了「整个服务卡死」;如果一半任务是 CPU 密集,该用进程池还是进程池。

写在最后

asyncio 的学习曲线不在语法,在心智模型。接受三件事就够了:

一,并发控制权交给调度器,代码要配合它而不是跟它抢。

二,取消是常态,每个 await 都要想清楚「被取消时会发生什么」。

三,背压是必需品,信号量不是优化项,是生存条件。

把三条刻进脑子里,剩下的只是把 gather 换成 TaskGroup、给每个 await 套上 wait_for、把 requests 扔掉。差不多就能上线了。差不多。

祝各位的连接池永远不满,日志里永远没有 Task was destroyed but it is pending。

相关文章

虚拟线程让接口更慢了:Java 21 Loom 一次 pinning 事故的现场复盘
你刚改完的数据怎么读不到了:MySQL 主从延迟这块黑箱,比你想象的黑
你的数据库连接池正在悄悄排队:21 个线程抢 10 个连接,然后集体石化
缓存和数据库打架的时候,到底谁先动手?
你写的正则正在用 2^n 的时间等你:回溯引擎的灾难性回溯,一次线上事故复盘
半夜三点,你的 Kafka 消费者在互相踢来踢去:一次 rebalance 风暴的现场重建

发布评论