一、问题背景

去年接手了一个商品详情页的聚合接口,逻辑很简单:前端传一个 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 用法是一样的。

三、方案设计

方案其实就三件事:

  1. 下游调用并行化:三个 HTTP 请求用 asyncio.gather 并发发出,总耗时从"三者之和"变成"三者最大值"。
  2. 换异步 HTTP 客户端:requests 是同步阻塞的,在协程里调用会卡死整个事件循环,必须换成 aiohttp.ClientSession。
  3. 控制并发和超时:给每个下游调用设独立的 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 服务就行。