一、问题背景:一个被同步IO拖死的聚合接口
事情是这样的。我们有个 /api/v1/user/profile 接口,本身不复杂,就是把用户信息从6个下游服务聚合起来返回给客户端:基础资料、账户余额、订单统计、消息未读数、会员等级、风控标签。每个下游都是独立的HTTP服务。
最初的实现非常"朴素",就是串行调用:
def get_user_profile(user_id: int):
base = requests.get(f"{BASE_URL}/user/{user_id}", timeout=2).json()
balance = requests.get(f"{ACCOUNT_URL}/balance/{user_id}", timeout=2).json()
orders = requests.get(f"{ORDER_URL}/stats/{user_id}", timeout=2).json()
unread = requests.get(f"{MSG_URL}/unread/{user_id}", timeout=2).json()
level = requests.get(f"{VIP_URL}/level/{user_id}", timeout=2).json()
risk = requests.get(f"{RISK_URL}/tags/{user_id}", timeout=2).json()
return merge(base, balance, orders, unread, level, risk)
单个下游平均耗时150-200ms,6个串起来就是900-1200ms。这还是正常情况下。一旦某个下游抖动,比如消息服务偶尔要800ms,接口延迟直接飙到1.5秒以上。
更致命的是部署方式:FastAPI 跑在 uvicorn 上,但这个路由函数是 def 不是 async def,会被扔进线程池执行。uvicorn 默认线程池就那么大,80万日调用量摊到高峰期,线程池分分钟被打满,请求开始排队,然后雪崩——一个慢下游能拖垮整个服务,这事我们真实经历过一次。
所以目标很明确:这6个调用之间没有依赖关系,完全可以并发。用 asyncio 重构,把"串行等待"变成"并发等待"。
二、环境与版本
先把版本交代清楚,避免有人说"我这里跑不通":
- Python 3.11.6(3.11 的 asyncio 在异常处理和 TaskGroup 上比 3.8 好用太多,强烈建议至少 3.10+)
- FastAPI 0.110.0
- uvicorn 0.27.1,启动参数
--workers 4 --loop uvloop - aiohttp 3.9.3(客户端)
- uvloop 0.19.0(事件循环加速,实测比默认 loop 快 10-15%)
- 压测工具:wrk 4.2.0,
wrk -t8 -c200 -d60s
下游服务都是内网 HTTP,平均 RTT 150-200ms,P99 约 500ms。
三、方案设计
核心思路就一句话:把6个串行HTTP调用改成并发,用 Semaphore 控制单接口并发量,用 asyncio.wait_for 加超时兜底,单个下游失败不拖垮整个接口。
几个设计决策说一下:
-
用 aiohttp 而不是 httpx。httpx 的 API 更现代,但我们这个场景是纯高频短请求,aiohttp 的连接池复用更成熟,实测同压下 aiohttp 的 P99 比 httpx(默认配置)低约 8%。当然 httpx 也完全能用,看团队习惯。
-
全局共享一个
aiohttp.ClientSession。这是 asyncio HTTP 客户端最常见的坑——每次请求新建 Session 会导致连接无法复用,性能比同步还差。必须用 FastAPI 的 lifespan 管理 Session 生命周期。 -
每个下游单独
wait_for超时,而不是整体超时。整体超时会让一个慢下游拖累其他已经返回的结果。我们给每个下游设 800ms 超时,超时的那个返回兜底值(比如未读数返回0),保证接口整体可用。 -
Semaphore 限流。单机并发太高会把下游打挂,用 Semaphore 把同时在途的下游请求控制在合理范围。这个值要压测调,我们最终定在 200。
四、核心实现
先看改造后的完整代码。Session 用 lifespan 管理:
# app/main.py
from contextlib import asynccontextmanager
import aiohttp
from fastapi import FastAPI
@asynccontextmanager
async def lifespan(app: FastAPI):
# 全局共享 Session,连接池上限按压测结果调
connector = aiohttp.TCPConnector(
limit=300, # 总连接数上限
limit_per_host=100, # 单host上限
ttl_dns_cache=300,
enable_cleanup_closed=True,
)
timeout = aiohttp.ClientTimeout(total=1.0, connect=0.3)
app.state.session = aiohttp.ClientSession(connector=connector, timeout=timeout)
app.state.sem = asyncio.Semaphore(200) # 全局并发闸门
yield
await app.state.session.close()
app = FastAPI(lifespan=lifespan)
聚合逻辑是重点,注意异常兜底和超时处理:
# app/profile.py
import asyncio
import logging
from fastapi import Request
logger = logging.getLogger(__name__)
DOWNSTREAMS = {
"base": ("{BASE_URL}/user/{uid}", None),
"balance": ("{ACCOUNT_URL}/balance/{uid}", {"balance": 0}),
"orders": ("{ORDER_URL}/stats/{uid}", {"order_count": 0}),
"unread": ("{MSG_URL}/unread/{uid}", {"unread": 0}),
"level": ("{VIP_URL}/level/{uid}", {"level": "unknown"}),
"risk": ("{RISK_URL}/tags/{uid}", {"tags": []}),
}
async def _fetch(session, sem, url, fallback, timeout=0.8):
async with sem: # 控制同时在途请求数
try:
async with session.get(url, timeout=timeout) as resp:
if resp.status != 200:
logger.warning("downstream %s status=%s", url, resp.status)
return fallback
return await resp.json()
except asyncio.TimeoutError:
logger.warning("downstream timeout: %s", url)
return fallback
except aiohttp.ClientError as e:
logger.warning("downstream error: %s %s", url, e)
return fallback
async def get_user_profile(request: Request, user_id: int):
session = request.app.state.session
sem = request.app.state.sem
tasks = {
name: asyncio.create_task(
_fetch(session, sem, url.format(uid=user_id), fallback)
)
for name, (url, fallback) in DOWNSTREAMS.items()
}
# base 是必选项,失败直接抛错;其余用兜底值
base = await tasks["base"]
if base is None:
raise HTTPException(status_code=502, detail="base service unavailable")
others = await asyncio.gather(
*(t for n, t in tasks.items() if n != "base"),
return_exceptions=True,
)
result = {"user_id": user_id, **base}
for name, val in zip([n for n in tasks if n != "base"], others):
result[name] = val if not isinstance(val, Exception) else DOWNSTREAMS[name][1]
return result
路由注册时用 async def,这一点别搞错,写成 def 就又回线程池了:
@app.get("/api/v1/user/profile/{user_id}")
async def profile(user_id: int, request: Request):
return await get_user_profile(request, user_id)
关键点复盘:asyncio.create_task 让6个请求同时起飞,gather 等全部完成;每个 _fetch 内部有独立超时和异常兜底;base 是强依赖单独处理,其余失败降级。整个接口的最坏耗时约等于最慢那个下游的超时时间(800ms),而不是6个下游之和。
五、踩坑与优化
坑1:Session 泄漏。 一开始图省事在函数里 async with aiohttp.ClientSession(),结果每个请求建一次连接池,QPS 上到 200 就开始报 "Too many open files"。改成全局 Session 后解决。这个坑太经典了,必须写在这。
坑2:gather 没加 return_exceptions=True。 第一版直接用 gather,某个下游抛异常整个接口 500。加上之后配合兜底逻辑才稳。
坑3:Semaphore 位置放错。 我一开始把 Semaphore 放在 _fetch 外面,结果发现 create_task 后 sem 还没来得及 acquire 所有任务都已经创建了,起不到限流作用。正确做法是 acquire 必须在协程内部、session.get 之前,像上面代码那样。
坑4:uvloop 和某些 C 扩展冲突。 我们有个下游 SDK 用了老版本 grpc,开 uvloop 后偶发段错误。后来把那个调用挪到 run_in_executor 才解决。如果你的依赖里有 C 扩展,开 uvloop 前先压测一遍。
优化:DNS 缓存。 下游域名解析在高峰期会抖动,给 TCPConnector 加 ttl_dns_cache=300,减少 DNS 查询开销,P99 又降了约 15ms。
优化:连接池参数。 limit=300 / limit_per_host=100 是压测调出来的。太小会排队,太大下游扛不住。建议从 limit = 并发数 × 平均在途时间 / 目标QPS 估算,再压测微调。
六、效果数据
压测条件:wrk -t8 -c200 -d60s,单机 4 worker,下游用 mock 服务模拟 150-200ms 延迟。
| 指标 | 改造前(同步串行) | 改造后(asyncio) | 提升 |
|---|---|---|---|
| P50 延迟 | 980ms | 168ms | 5.8x |
| P99 延迟 | 1240ms | 182ms | 6.8x |
| 单机 QPS | 95 | 620 | 6.5x |
| 峰值内存 | 1.4GB | 980MB | -30% |
| 线程池打满告警 | 高峰期必现 | 0 | - |
线上灰度一周,接口错误率从 0.8% 降到 0.05%(主要是下游超时被兜底了,不再返回 500),CPU 使用率反而下降了约 20%——因为线程切换开销没了。最直观的感受是,之前高峰期值班群里天天有人 @ 我说接口慢,现在清净了。
七、总结
这次改造的核心其实不是"用了 asyncio"这么简单,而是三件事:识别出可并发的IO边界、给每个并发单元独立的超时和降级、用连接池和信号量把资源管住。asyncio 只是工具,设计才是关键。
几个可以直接抄走的经验:
ClientSession一定全局复用,用 lifespan 管理。- 每个下游独立
wait_for,别用整体超时。 - 强依赖和弱依赖分开处理,弱依赖失败降级。
- Semaphore 的 acquire 必须在协程内部。
- 上 uvloop 前先确认依赖里没有坑爹的 C 扩展。
如果你的服务也是这种"聚合多个下游"的模式,并且还在用同步 requests 串行调用,别犹豫,改吧。收益比你想的大。
(完)