一、问题背景:一个被同步IO拖死的聚合接口

去年接手了一个商品详情聚合接口,逻辑很简单:前端传一个 sku_id,后端并发地去调三个下游——商品基础信息、库存服务、价格服务,拼成一个 JSON 返回。

听起来像是个"并发"场景,但代码写出来是这样的:

# before: app.py (Flask 2.3.3 + requests 2.31.0)
@app.route("/api/v1/product/")
def product_detail(sku_id):
    base = requests.get(f"{BASE_URL}/base/{sku_id}", timeout=2).json()
    stock = requests.get(f"{STOCK_URL}/stock/{sku_id}", timeout=2).json()
    price = requests.get(f"{PRICE_URL}/price/{sku_id}", timeout=2).json()
    return {"base": base, "stock": stock, "price": price}

三个下游平均耗时分别是 60ms / 90ms / 70ms,串行加起来 220ms 起步。高峰期 P99 直接飙到 480ms。

更致命的是部署方式:gunicorn -w 8 --threads 4,单机 32 个 worker 线程,每个线程同一时刻只能处理一个请求,全部阻塞在 requests.get 上。压测结果单机 QPS 180,CPU 利用率不到 15%——机器全在等网络,一点活没干。

这就是典型的 IO 密集型服务用同步模型硬扛的后果。我们的目标很明确:不改下游,只改调用方式,用 asyncio 把等待时间重叠起来。

二、环境与版本

先把环境钉死,异步这套东西版本差异很大,尤其是 httpx 在 0.20 前后的 API 变过:

  • Python 3.11.6(选 3.11 是因为 asyncio.TaskGroup 从 3.11 才进标准库,比 gather 好做异常处理)
  • httpx 0.27.0(AsyncClient + 连接池复用)
  • FastAPI 0.111.0 + uvicorn 0.30.1(换掉 Flask,因为 Flask 是 WSGI,跑不了原生 async view)
  • 部署:uvicorn --workers 4,单容器 2C4G

为什么必须换框架?Flask 2.x 虽然能 async def 视图,但底层还是 WSGI,每个请求跑在独立事件循环里,异步等于没异步,甚至更慢。这点后面踩坑章节会细说。

三、方案设计

核心思路三层:

  1. IO 并发化:三个下游调用用 asyncio.gather 并发发出,总耗时从"三者之和"变成"三者最大值",理论 220ms → 90ms。
  2. 连接池复用:httpx.AsyncClient 全局单例,配置 limits=httpx.Limits(max_connections=200, max_keepalive_connections=50),避免每次请求重建 TCP/TLS。
  3. 超时与降级:每个下游单独设 timeout=1.5s,用 return_exceptions=True 让某个下游挂了也能返回部分数据,而不是整体 500。

另外加了一个细节:库存和价格这两个服务对实时性要求没那么高,允许 300ms 的本地缓存(cachetools.TTLCache),进一步削峰。这个不在本次对比数据里,算额外收益。

四、核心实现

after 版本的代码,FastAPI + httpx:

# after: main.py (FastAPI 0.111.0 + httpx 0.27.0, Python 3.11)
import asyncio
import httpx
from fastapi import FastAPI, HTTPException

app = FastAPI()

# 全局单例 client,lifespan 里创建/关闭,复用连接池
client: httpx.AsyncClient | None = None

@app.on_event("startup")
async def startup():
    global client
    client = httpx.AsyncClient(
        timeout=httpx.Timeout(1.5, connect=0.5),
        limits=httpx.Limits(max_connections=200, max_keepalive_connections=50),
    )

@app.on_event("shutdown")
async def shutdown():
    await client.aclose()

async def fetch(url: str) -> dict:
    resp = await client.get(url)
    resp.raise_for_status()
    return resp.json()

@app.get("/api/v1/product/{sku_id}")
async def product_detail(sku_id: int):
    urls = [
        f"{BASE_URL}/base/{sku_id}",
        f"{STOCK_URL}/stock/{sku_id}",
        f"{PRICE_URL}/price/{sku_id}",
    ]
    # return_exceptions=True:单个下游失败不拖垮整体
    results = await asyncio.gather(
        *(fetch(u) for u in urls), return_exceptions=True
    )
    base, stock, price = results
    if isinstance(base, Exception):
        raise HTTPException(status_code=502, detail="base service unavailable")
    return {
        "base": base,
        "stock": None if isinstance(stock, Exception) else stock,
        "price": None if isinstance(price, Exception) else price,
    }

几个关键点解释一下:

  • httpx.Timeout(1.5, connect=0.5) 是分项超时,连接阶段 0.5s 卡死就放弃,比一个笼统的 1.5s 更早暴露下游网络问题。
  • max_keepalive_connections=50 是经验值:单 worker 并发峰值大概 40 左右,留点余量。设太大反而会因为下游 keepalive 策略不一致产生大量 CLOSE_WAIT。
  • gather(return_exceptions=True) 配合 isinstance 判断,实现"基础信息必须成功,库存价格可降级"的业务语义。

如果想更现代一点,Python 3.11 可以用 TaskGroup,异常传播更清晰,但 gather 的 return_exceptions 在"部分失败可接受"场景下反而更顺手,所以这里没换。

五、踩坑与优化

坑 1:Flask 里写 async def 是负优化。 一开始偷懒,直接在 Flask 里把 view 改成 async def 然后用 asyncio.run 包一层。结果 QPS 反而掉到 120。原因是 WSGI 每个请求新建事件循环,连接池根本复用不了,还多了事件循环的创建销毁开销。结论:异步必须配 ASGI 服务器,Flask 要么换 FastAPI,要么老老实实上 gevent。

坑 2:全局 AsyncClient 不能在每个请求里 new。 早期版本在 view 里 async with httpx.AsyncClient() as c,压测时 QPS 只有 600,ss -s 一看 TIME_WAIT 堆到 3 万多。改成 lifespan 单例后直接翻倍。这是异步 HTTP 客户端最常见的错误。

坑 3:uvicorn worker 数和连接池要匹配。 一开始 --workers 8,每个 worker 一个事件循环一个 client,总连接数 8×200=1600,把下游 Nginx 的 worker_connections 1024 打满了,开始出现 502。后来降到 --workers 4,max_connections 调到 200,总 800,稳了。worker 数不是越多越好,要按下游承载能力倒推。

坑 4:事件循环里混入同步代码。 有个日志埋点用了同步的 requests.post 上报,虽然只有 5ms,但在事件循环里就是全局阻塞。用 asyncio.to_thread 包一层或者换 httpx 异步上报。任何超过 1ms 的同步调用在异步服务里都是毒药。

优化项:加了 orjson 做序列化(FastAPI 默认 json 库),大 JSON 场景下序列化耗时从 8ms 降到 2ms;uvloop 替换默认事件循环,QPS 再涨约 12%。

六、效果数据

压测工具 wrk -t8 -c200 -d60s,下游用固定延迟 mock(60/90/70ms),单机 2C4G 结果:

指标 before (Flask+gunicorn) after (FastAPI+uvicorn)
单机 QPS 180 2100
P50 延迟 235ms 92ms
P99 延迟 480ms 95ms
CPU 利用率 13% 68%
单机内存 420MB 310MB
生产机器数 8 台 2 台

P99 从 480ms 掉到 95ms,基本等于单个最慢下游的耗时,说明并发聚合完全生效了。QPS 提升 11.6 倍,机器从 8 台缩到 2 台,按当时的云主机单价算,一年省下来的钱够团队吃好几顿火锅。

需要注意的是,QPS 2100 是 mock 下游的极限,真实下游有容量上限,上线后我们做了限流(slowapi,单实例 1500 QPS),实际稳定在 1400 左右,仍然远超改造前。

七、总结

这次改造最大的体会是:异步不是换个 async def 就完事,它是一整套 IO 模型的选择——框架(ASGI)、客户端(连接池复用)、服务器(worker 数)、事件循环(uvloop)任何一环掉链子,收益都会大打折扣。

适用边界也要说清楚:如果你的接口是 CPU 密集型(比如图片处理、复杂计算),asyncio 一点用没有,该上多进程上多进程。异步只解决"等待"的问题,不解决"计算"的问题。

最后给想动手的同学一个最小行动清单:先把同步 HTTP 调用换成 httpx.AsyncClient 全局单例,再把框架换成 FastAPI/Starlette,压测对比一轮,数据会说服你的。