一、问题背景

去年接手了一个商品详情聚合接口,逻辑很朴素:客户端传一个 sku_id,服务端去调三个下游——商品基础信息、库存、价格。三个下游都是独立的HTTP服务,彼此没有依赖。

原来的实现是Flask + requests,同步阻塞,代码大概长这样:

@app.route("/api/sku/")
def sku_detail(sku_id):
    base = requests.get(f"{BASE_URL}/sku/{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}

问题很明显:三次调用串行执行,每次平均耗时150ms左右,接口整体延迟就是450ms起步。线上用gunicorn起了8个sync worker,压测QPS卡在120左右,P99延迟1.8s(下游抖动时更惨)。大促前容量评估直接过不了。

其实这三个调用完全可以并发,这就是asyncio最典型的适用场景。这篇文章记录一下改造过程。

二、环境与版本

  • Python 3.11.6(3.11的asyncio在异常处理和TaskGroup上有明显改进,建议至少3.10+)
  • FastAPI 0.110.0
  • uvicorn 0.29.0
  • httpx 0.27.0(异步HTTP客户端,替代requests)
  • 压测工具:wrk 4.2.0,wrk -t4 -c200 -d60s

选httpx而不是aiohttp,主要是API和requests接近,迁移成本低,而且支持HTTP/2。注意httpx的AsyncClient必须复用,每次请求新建client会直接把连接池优势吃光,这个后面踩坑部分细说。

三、方案设计

核心思路就一句话:把串行的三次IO等待变成并发等待。

但有几个设计决策需要说明:

  1. Web框架换不换。Flask本身是同步WSGI,也可以套asgiref跑async视图,但生态和性能都不如直接上FastAPI(ASGI原生)。考虑到团队接受度,最终选FastAPI。

  2. 并发编排方式。用asyncio.gather而不是asyncio.wait,因为我们需要三个结果全部拿到才返回,gather语义更直接。设置return_exceptions=True,让单个下游失败不拖垮整个接口。

  3. 超时控制。外层用asyncio.wait_for整体兜底2s,内层httpx client单独设timeout=1.5。双层超时是有意的:内层控制单次调用,外层防止gather整体被某个慢调用拖死。

  4. 降级策略。库存和价格失败时返回默认值(库存显示"未知"、价格取基础信息里的兜底价),基础信息失败才整体报错。这个策略是跟业务方对齐过的。

四、核心实现

先看改造后的完整代码:

import asyncio
import httpx
from fastapi import FastAPI, HTTPException

app = FastAPI()

# 全局复用 client,连接池上限按下游并发量估算
client = httpx.AsyncClient(
    timeout=httpx.Timeout(1.5, connect=0.5),
    limits=httpx.Limits(max_connections=200, max_keepalive_connections=50),
)

BASE_URL = "http://sku-svc"
STOCK_URL = "http://stock-svc"
PRICE_URL = "http://price-svc"


async def fetch_json(url: str):
    resp = await client.get(url)
    resp.raise_for_status()
    return resp.json()


async def get_sku_detail(sku_id: int):
    async def safe_fetch(url, default=None):
        try:
            return await fetch_json(url)
        except Exception as e:
            # 记录日志后降级,不让单点失败扩散
            print(f"fetch failed: {url}, err={e}")
            return default

    base_task = fetch_json(f"{BASE_URL}/sku/{sku_id}")
    stock_task = safe_fetch(f"{STOCK_URL}/stock/{sku_id}", default={"count": -1})
    price_task = safe_fetch(f"{PRICE_URL}/price/{sku_id}", default={"price": None})

    try:
        base, stock, price = await asyncio.wait_for(
            asyncio.gather(base_task, stock_task, price_task),
            timeout=2.0,
        )
    except asyncio.TimeoutError:
        raise HTTPException(status_code=504, detail="upstream timeout")
    except httpx.HTTPStatusError as e:
        raise HTTPException(status_code=502, detail=f"upstream error: {e.response.status_code}")

    return {"base": base, "stock": stock, "price": price}


@app.get("/api/sku/{sku_id}")
async def sku_detail(sku_id: int):
    return await get_sku_detail(sku_id)

几个关键点:

  • client 是模块级全局对象,在应用生命周期内复用。FastAPI的startup/shutdown事件里应该补上await client.aclose(),我这里为了代码简洁省略了,生产环境必须加。
  • safe_fetch 把异常吞掉返回默认值,只有base_task的异常会向上抛。这样库存服务挂了不影响主流程。
  • wait_for 包在 gather 外面,超时后gather里的Task会被cancel,httpx会中断请求,不会泄漏连接。

启动命令:

uvicorn main:app --host 0.0.0.0 --port 8000 \
  --workers 4 --loop uvloop --http httptools

--workers 4 对应4核机器。注意asyncio是单线程事件循环,多核必须靠多worker进程,别指望一个worker吃满CPU。uvloop 和 httptools 是uvicorn的性能选项,实测QPS能再涨15%左右。

五、踩坑与优化

这块是重点,网上教程基本不讲。

坑1:client建在函数里。第一版我图省事,在每个请求里 async with httpx.AsyncClient() as c,压测QPS只有400。原因是每次请求都新建连接池、重新TCP握手,完全没复用。改成全局client后直接翻了几倍。这是异步HTTP客户端最常见的错误。

坑2:以为gather会自动处理异常。默认return_exceptions=False时,gather里任何一个Task抛异常,整个gather立即抛异常返回,其他Task的结果直接丢弃。我一开始没设这个参数,库存服务一抖动整个接口就500。后来改成每个子任务内部try/except,比依赖gather的异常聚合更可控。

坑3:同步代码混进事件循环。改造初期有个日志函数用了同步的requests打点,结果整个事件循环被阻塞,QPS暴跌。asyncio的铁律:事件循环里不能有任何同步阻塞调用,包括文件IO、CPU密集计算、同步DB驱动。CPU密集的活丢到loop.run_in_executor或者干脆拆服务。

坑4:连接池上限设小了。max_connections=200 是压测调出来的。一开始设50,200并发下大量请求在等连接,P99反而比改造前还高。经验公式:max_connections ≈ QPS × 平均下游延迟(s) × 安全系数1.5。2100 QPS × 0.15s × 1.5 ≈ 470,但实际因为连接复用率高,200就够,具体要压测看。

优化:超时分层。connect超时0.5s,读超时1.5s,外层wait_for 2s。下游偶发慢请求时,快速失败比死等体验好得多。

六、效果数据

同一台4核8G机器,wrk 200并发压测60秒:

指标 改造前(Flask+gunicorn 8w) 改造后(FastAPI+uvicorn 4w)
QPS 120 2100
P50延迟 420ms 95ms
P99延迟 1800ms 210ms
CPU占用 85% 40%
内存 1.2GB 380MB

QPS提升约17倍,P99降到原来的1/8。CPU反而降了一半,因为同步worker大量时间在等IO,上下文切换开销也大。内存降是因为gunicorn 8个进程各自加载一份应用。

需要说明:这个数据是在下游稳定(延迟150ms左右)的情况下测的。下游抖动时,改造后的接口因为有并发+超时兜底,P99优势会更明显。

七、总结

asyncio不是什么银弹,它只解决IO密集型场景的并发等待问题。这个接口能提升17倍,本质是因为原来三次串行IO变成了并发,理论下限就是3倍,加上框架和连接复用的收益才到这个数。

几条实际建议:

  1. 判断要不要用asyncio,看你的瓶颈是不是IO等待。CPU密集的活上asyncio只会更慢。
  2. 异步客户端(httpx/aiohttp/asyncpg)必须全局复用,连接池参数要压测调。
  3. 事件循环里严禁同步阻塞,这条违反一次性能就崩。
  4. 超时、降级、异常隔离要做在并发编排这一层,别指望框架兜底。

代码已经跑在生产上三个月了,大促期间峰值QPS 3500左右,没出过事故。下一步打算把下游调用改成gRPC,延迟还能再压一截。