一、问题背景
去年接手了一个商品详情页的聚合接口,逻辑很简单:前端传一个 sku_id,后端分别去三个内部服务拿数据,拼成一个 JSON 返回。
- 库存服务:
GET /stock/{sku_id},平均 60ms - 价格服务:
GET /price/{sku_id},平均 90ms - 评论服务:
GET /comment/{sku_id},平均 120ms
最初的实现是最直白的串行调用,用 requests 一个一个发。三个下游加起来平均 270ms,加上框架开销,接口平均延迟 300ms 左右。这个数字在业务上勉强能用,但随着大促临近,压测结果很难看:单机 4 核 8G,QPS 只跑到 320 就开始大量超时,P99 直接飙到 480ms。
原因也很清楚:这是个典型的 IO 密集型接口,线程绝大部分时间都在等网络,串行调用把三个本可以并行的等待时间叠加了。而且 Flask 默认的多线程模型下,每个请求占一个线程,线程数一上去上下文切换和内存开销都很可观。
所以目标很明确:把三个下游调用并行化,同时换掉"一请求一线程"的模型。
二、环境与版本
先交代清楚环境,不然数据没法复现:
- Python 3.8.10(当时线上的版本,没敢动)
- Flask 1.1.2 + gunicorn 20.1.0(before)
- aiohttp 3.8.4 + asyncio(after)
- requests 2.25.1(before)
- 压测工具:wrk 4.1.0,
wrk -t4 -c200 -d60s - 机器:4 核 8G,同机部署,下游服务用 mock 服务模拟固定延迟
before 的部署方式是 gunicorn -w 4 --threads 8,after 是 gunicorn -w 4 -k aiohttp.GunicornWebWorker(aiohttp 自带的 worker)。
这里提前说一句:我选的是 aiohttp 而不是 FastAPI,原因是这个服务已经存在,Flask 的路由和中间件逻辑想尽量保留,aiohttp 的 web 框架迁移成本最低,而且不需要引入 pydantic 那一套。如果你是新项目,FastAPI 也完全没问题,核心的 asyncio 用法是一样的。
三、方案设计
方案其实就三件事:
- 下游调用并行化:三个 HTTP 请求用
asyncio.gather并发发出,总耗时从"三者之和"变成"三者最大值"。 - 换异步 HTTP 客户端:
requests是同步阻塞的,在协程里调用会卡死整个事件循环,必须换成aiohttp.ClientSession。 - 控制并发和超时:给每个下游调用设独立的
timeout,并且用信号量限制单机对单个下游的最大并发连接数,避免把下游打挂。
有一个设计取舍值得说:三个下游里,评论服务的延迟最高(120ms),但它对页面首屏不是必需的。所以我在实现里给评论服务单独设了 150ms 的超时,超时后返回空列表,页面照常渲染。这个降级策略在压测时对 P99 的改善非常明显。
四、核心实现
Before:串行版本
# app_sync.py
import requests
from flask import Flask, jsonify, request
app = Flask(__name__)
STOCK_URL = "http://stock.svc/stock/{sku_id}"
PRICE_URL = "http://price.svc/price/{sku_id}"
COMMENT_URL = "http://comment.svc/comment/{sku_id}"
@app.route("/api/item/")
def item_detail(sku_id):
# 三次串行调用,总耗时 = 60 + 90 + 120 ≈ 270ms
stock = requests.get(STOCK_URL.format(sku_id=sku_id), timeout=1.0).json()
price = requests.get(PRICE_URL.format(sku_id=sku_id), timeout=1.0).json()
comment = requests.get(COMMENT_URL.format(sku_id=sku_id), timeout=1.0).json()
return jsonify({
"sku_id": sku_id,
"stock": stock,
"price": price,
"comment": comment,
})
这段代码没什么可挑剔的,问题只在于它是串行的。
After:asyncio 版本
# app_async.py
import asyncio
import aiohttp
from aiohttp import web
STOCK_URL = "http://stock.svc/stock/{sku_id}"
PRICE_URL = "http://price.svc/price/{sku_id}"
COMMENT_URL = "http://comment.svc/comment/{sku_id}"
# 全局 session,复用连接池;不要每个请求新建
SESSION = None
# 限制对每个下游的最大并发,防止打挂下游
SEMAPHORES = {}
async def fetch(session, url, timeout, sem):
async with sem:
try:
async with session.get(url, timeout=aiohttp.ClientTimeout(total=timeout)) as resp:
if resp.status != 200:
return None
return await resp.json()
except asyncio.TimeoutError:
return None
except aiohttp.ClientError:
return None
async def item_detail(request):
sku_id = request.match_info["sku_id"]
session = request.app["session"]
sems = request.app["semaphores"]
# 三个请求并发发出,评论服务单独设 150ms 超时并允许降级
stock_task = fetch(session, STOCK_URL.format(sku_id=sku_id), 1.0, sems["stock"])
price_task = fetch(session, PRICE_URL.format(sku_id=sku_id), 1.0, sems["price"])
comment_task = fetch(session, COMMENT_URL.format(sku_id=sku_id), 0.15, sems["comment"])
stock, price, comment = await asyncio.gather(stock_task, price_task, comment_task)
return web.json_response({
"sku_id": sku_id,
"stock": stock,
"price": price,
"comment": comment or [], # 评论降级为空列表
})
async def create_app():
app = web.Application()
app["session"] = aiohttp.ClientSession(
connector=aiohttp.TCPConnector(limit=200, limit_per_host=100, ttl_dns_cache=300),
trust_env=False,
)
app["semaphores"] = {
"stock": asyncio.Semaphore(80),
"price": asyncio.Semaphore(80),
"comment": asyncio.Semaphore(60),
}
app.router.add_get("/api/item/{sku_id}", item_detail)
return app
if __name__ == "__main__":
web.run_app(create_app(), port=8080)
几个关键参数说明一下:
TCPConnector(limit=200, limit_per_host=100):全局连接池 200,单 host 100。一开始我用默认值(100/0,即不限单 host),压测时对评论服务打出了 300+ 并发连接,下游直接开始拒绝连接,所以必须显式限制。ttl_dns_cache=300:DNS 缓存 5 分钟,避免每个请求都做一次解析。trust_env=False:线上容器里有HTTP_PROXY环境变量,aiohttp 默认会读取,导致请求走代理绕一圈,延迟凭空多了 20ms。- 评论服务的
timeout=0.15:比它平均延迟 120ms 略高,留一点余量。
五、踩坑与优化
坑 1:在协程里调用了 requests。 第一版改造时,我在一个工具函数里顺手用了 requests.get 做兜底,结果压测时 QPS 死活上不去,asyncio 的 debug 模式打开后看到大量 "Executing took 0.09 seconds" 的警告。原因是同步阻塞调用会卡住整个事件循环,一个请求的 90ms 等待会让同 worker 里所有协程一起等。结论:协程里绝对不能碰任何同步 IO 库。
坑 2:每个请求新建 ClientSession。 早期版本我在 handler 里 async with aiohttp.ClientSession(),压测时 QPS 只有 900,而且 TIME_WAIT 连接数暴涨。ClientSession 内部持有连接池,每次新建等于每次重建连接池,TCP 握手和 TLS 开销全回来了。改成应用级单例后 QPS 直接翻倍。
坑 3:超时设置的位置。 aiohttp 的 timeout 参数在不同版本里行为不一样。3.8 里我统一用 ClientTimeout(total=...),不要用已废弃的 timeout=float 写法,后者在 3.9+ 会直接报错。另外 total 包含了连接建立时间,如果你只想限制读取时间,要用 sock_read。
坑 4:gunicorn worker 的选择。 一开始我用 -k aiohttp.GunicornWebWorker 起了 4 个 worker,但每个 worker 是独立的事件循环,连接池和信号量都是 per-worker 的。也就是说 limit_per_host=100 在 4 worker 下实际是 400。后来我把压测时的下游连接数监控对上,才发现这个问题,把 limit_per_host 调到 40,实际总并发控制在 160,下游才稳定。
坑 5:CPU 密集型逻辑没地方放。 这个接口里有个价格格式化的小函数,纯计算,但偶尔会处理大列表(比如满减规则上百条)。协程里跑这种代码会阻塞事件循环,我后来用 loop.run_in_executor 把它丢到线程池,虽然这次的场景数据量不大,但属于必须提前防的坑。
六、效果数据
同一台机器、同一套 mock 下游(固定延迟 60/90/120ms)、同样的 wrk 参数 -t4 -c200 -d60s:
| 指标 | Before(Flask 串行) | After(aiohttp + asyncio) |
|---|---|---|
| QPS | 320 | 2100 |
| 平均延迟 | 310ms | 78ms |
| P95 延迟 | 420ms | 88ms |
| P99 延迟 | 480ms | 95ms |
| 错误率 | 2.1%(超时) | 0.03% |
| CPU 使用率 | 78% | 41% |
| 常驻内存 | 约 380MB | 约 210MB |
几个值得注意的点:
- QPS 提升 6.5 倍,但延迟只降到 78ms,而不是理论上的 120ms(三者最大值)。差距来自框架开销和事件循环调度,以及评论服务 150ms 超时后仍有部分请求触发降级路径。
- P99 从 480ms 降到 95ms,主要是并行化 + 评论降级的功劳。降级前 P99 一直卡在评论服务的长尾上。
- CPU 反而降了一半,因为线程模型从"每请求一线程"变成了单线程事件循环,上下文切换开销没了。
- 内存下降主要是线程栈的节省,200 并发下 before 有 200 个活跃线程。
补充一个细节:在 200 并发下,after 版本的事件循环单 worker 的 CPU 占用大约 25%,说明还有余量。如果下游延迟稳定,理论上还能再往上压,但下游服务的容量是瓶颈,我们没继续压。
七、总结
这次改造的核心其实就一句话:IO 密集的聚合接口,用 asyncio 把串行等待变成并行等待,收益是线性的。三个下游并行后理论耗时从 270ms 降到 120ms,实际因为框架和调度开销落在 78ms 平均(因为部分请求评论降级后更快)。
但真正让 QPS 从 320 走到 2100 的,不只是 asyncio 本身,还有几个配套动作:连接池复用、per-host 并发限制、超时降级、gunicorn worker 模型调整。任何一个没做,数据都会打折——我中间有一版只做了并行化但每请求新建 Session,QPS 只有 900。
如果你也要做类似改造,我的建议是:先确认瓶颈确实在 IO 等待(看线程栈或者打个火焰图),再动手;改造时优先保证"协程里没有同步阻塞调用"这一条铁律;最后一定要把下游的并发上限和超时降级一起设计进去,否则异步化只是把压力更猛地灌给下游而已。
代码都在上面两个块里,aiohttp 3.8.4 + Python 3.8 可直接跑,把三个 URL 换成你的 mock 服务就行。