一、问题背景:一个被同步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,每个请求跑在独立事件循环里,异步等于没异步,甚至更慢。这点后面踩坑章节会细说。
三、方案设计
核心思路三层:
- IO 并发化:三个下游调用用
asyncio.gather并发发出,总耗时从"三者之和"变成"三者最大值",理论 220ms → 90ms。 - 连接池复用:
httpx.AsyncClient全局单例,配置limits=httpx.Limits(max_connections=200, max_keepalive_connections=50),避免每次请求重建 TCP/TLS。 - 超时与降级:每个下游单独设
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,压测对比一轮,数据会说服你的。