一、问题背景

去年年底接手了一个商品详情聚合接口。业务逻辑不复杂:客户端传商品ID进来,服务端要去调三个下游——商品基础信息服务、库存服务、促销服务,再从Redis里读一次用户维度的个性化标签,最后拼装返回。

原来的实现是Flask + requests,纯同步写法:

@app.route("/api/product/")
def product_detail(pid):
    base = requests.get(f"{BASE_URL}/product/{pid}", timeout=2).json()
    stock = requests.get(f"{STOCK_URL}/stock/{pid}", timeout=2).json()
    promo = requests.get(f"{PROMO_URL}/promo/{pid}", timeout=2).json()
    tags = redis_client.get(f"tags:{pid}")
    return jsonify(merge(base, stock, promo, tags))

四个IO操作串行执行,每个下游平均耗时30~80ms,加起来单请求就要200ms以上。压测(wrk,8线程400连接,持续60秒)结果:QPS 120,P99 1.8s。上游调用方天天投诉超时。

问题很明显:这是个典型的IO密集型接口,CPU几乎全程空闲,时间全花在等网络返回上。四个下游之间没有依赖关系,完全可以并发。

二、环境与版本

  • Python 3.11.4(3.11的asyncio在异常处理和TaskGroup上有明显改进,建议至少3.10+)
  • Flask 2.3.3
  • aiohttp 3.8.5
  • redis-py 4.6.0(用redis.asyncio)
  • gunicorn 21.2.0 + uvicorn worker(异步改造后必须换异步worker,这点后面踩坑部分细说)
  • 压测工具:wrk 4.2.0

机器配置:8核16G,下游服务走内网,RTT约0.5ms。

三、方案设计

核心思路就一句话:把四个串行IO改成并发,同时控制好并发度别把下游打挂。

具体设计:

  1. Web层从Flask换成Flask + uvicorn worker?不行。Flask是WSGI,天生同步。要么整个迁到FastAPI/Starlette,要么用asgiref的async_to_sync在Flask里跑协程——后者是伪异步,一个worker里还是串行处理请求,治标不治本。

我选择了最小改动方案:保留Flask做路由和参数校验,但把耗时的聚合逻辑抽成一个独立的asyncio服务层,Web层通过一个常驻的event loop提交任务。实际落地时更干脆——直接把接口层换成FastAPI,因为改造成本差不多,而FastAPI原生async更干净。下面代码用FastAPI展示,这也是我最终上线的版本。

  1. 下游调用统一用aiohttp的ClientSession,全局单例,配连接池:TCPConnector(limit=200, limit_per_host=50)。

  2. 用asyncio.gather并发四个调用,加asyncio.Semaphore限制单接口并发度,防止突发流量打穿下游。

  3. 每个下游调用包一层asyncio.wait_for做超时,超时的下游降级返回默认值,不让整个请求失败。

  4. Redis用redis.asyncio,和aiohttp共用同一个event loop。

四、核心实现

先看改造后的核心代码:

import asyncio
import aiohttp
from fastapi import FastAPI
from redis.asyncio import Redis

app = FastAPI()

# 全局单例,在lifespan里初始化
session: aiohttp.ClientSession = None
redis: Redis = None
sem = asyncio.Semaphore(300)  # 单实例最大并发请求数

@app.on_event("startup")
async def startup():
    global session, redis
    connector = aiohttp.TCPConnector(
        limit=200,            # 连接池总上限
        limit_per_host=50,    # 单host上限
        ttl_dns_cache=300,
        enable_cleanup_closed=True,
    )
    timeout = aiohttp.ClientTimeout(total=1.5, connect=0.5)
    session = aiohttp.ClientSession(connector=connector, timeout=timeout)
    redis = Redis(host="10.0.0.12", port=6379, max_connections=100,
                  decode_responses=True)

@app.on_event("shutdown")
async def shutdown():
    await session.close()
    await redis.close()

async def fetch_json(url: str, default=None):
    try:
        async with session.get(url) as resp:
            if resp.status != 200:
                return default
            return await resp.json()
    except (asyncio.TimeoutError, aiohttp.ClientError):
        return default  # 降级

async def get_tags(pid: int):
    try:
        return await asyncio.wait_for(redis.get(f"tags:{pid}"), timeout=0.3)
    except asyncio.TimeoutError:
        return None

@app.get("/api/product/{pid}")
async def product_detail(pid: int):
    async with sem:
        base, stock, promo, tags = await asyncio.gather(
            fetch_json(f"{BASE_URL}/product/{pid}", default={}),
            fetch_json(f"{STOCK_URL}/stock/{pid}", default={"stock": -1}),
            fetch_json(f"{PROMO_URL}/promo/{pid}", default={}),
            get_tags(pid),
        )
    return merge(base, stock, promo, tags)

几个关键点解释一下:

连接池参数。limit=200是单进程总连接上限,limit_per_host=50限制单下游。我一开始只设了limit=100没设per_host,结果促销服务那边连接被占满,其他下游排队。per_host按下游实际QPS分配,促销服务QPS最高,给了50。

超时分层。ClientTimeout(total=1.5, connect=0.5),连接超时短、总超时长,因为内网建连很快,慢基本是下游处理慢。Redis单独wait_for(0.3),缓存读不该拖慢主链路。

降级策略。每个下游失败返回default,用gather的默认行为(不设return_exceptions=True,因为fetch_json内部已经吞了异常)。这样单下游挂掉接口仍可用,只是字段缺失。

信号量。Semaphore(300)限制单实例并发,配合gunicorn的worker数控制总并发。8核机器我配了4个uvicorn worker,理论最大并发1200,实测压到1400 QPS时信号量基本打满,但这个量级下游扛得住。

启动命令:

gunicorn main:app \
  -k uvicorn.workers.UvicornWorker \
  -w 4 \
  --max-requests 10000 \
  --max-requests-jitter 1000 \
  -b 0.0.0.0:8000

五、踩坑与优化

坑1:在协程里调了同步库,整个loop被阻塞。

改造初期我在fetch_json里图省事用了requests,想着"反正外面包了async"。结果压测QPS只有90,比原来还低。原因是requests.get是阻塞调用,它阻塞的是整个event loop,所有协程一起卡住。用py-spy dump一看,worker进程全卡在socket recv上。

教训:异步函数里绝对不能出现同步IO。要么换成原生async库(aiohttp/httpx/redis.asyncio),要么用loop.run_in_executor丢到线程池。我全部换成了aiohttp。

坑2:ClientSession在函数内创建,连接池反复重建。

最开始图方便,每次请求async with aiohttp.ClientSession() as s,结果QPS上不去,netstat看到大量TIME_WAIT。ClientSession本身持有连接池,必须全局复用。改成lifespan里初始化单例后,连接复用率上来了,QPS直接翻倍。

坑3:uvicorn worker数配错。

一开始沿用Flask时代的-w 8(等于核数),结果每个worker一个loop、一个连接池,8个worker × 200连接 = 1600个连接打向下游,促销服务直接限流。改成-w 4,配合per_host=50,总连接控制在800以内,稳定了。

优化:给gather加整体超时。

gather里单个调用有超时,但极端情况下(比如信号量排队)整体仍可能拖长。外层再包一个asyncio.wait_for(asyncio.gather(...), timeout=2.0)兜底,超时返回部分降级结果。

六、效果数据

同一台机器、同一份压测脚本(wrk -t8 -c400 -d60s),改造前后对比:

指标 Before (Flask+requests) After (FastAPI+asyncio)
QPS 120 1400
P50 延迟 320ms 68ms
P99 延迟 1.8s 210ms
错误率 2.3%(超时) 0.01%
CPU 使用率 15% 62%
内存 380MB 520MB

QPS提升约11.6倍,P99降低88%。CPU从15%涨到62%是预期的——原来CPU在睡觉,现在终于干活了。内存涨了140MB主要是4个worker各自的连接池和协程栈开销,可接受。

线上灰度一周,日均200万请求,P99稳定在200~230ms,下游服务无异常告警。

七、总结

这次改造的核心不是"用了asyncio",而是认清了接口瓶颈在IO等待。几个可复用的经验:

  1. 判断要不要异步,看CPU利用率。低于30%且延迟高,基本是IO瓶颈,异步收益大。
  2. ClientSession、Redis连接、信号量这些必须全局单例,在lifespan里管理生命周期。
  3. 异步函数里禁止同步IO,这是最容易犯也最难查的错,py-spy是排查利器。
  4. worker数不是越多越好,每个worker独立连接池,要按下游承载能力反推。
  5. 降级和超时要分层设计,单下游超时不能拖垮整个请求。

最后提醒一句:asyncio不是银弹。如果下游是CPU密集或者有强依赖链,异步帮不上忙。但如果你的接口像我这个一样,是一堆互不依赖的IO拼接,那改造收益会非常直接。