一、问题背景
去年年底接手了一个商品详情聚合接口。业务逻辑不复杂:客户端传商品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改成并发,同时控制好并发度别把下游打挂。
具体设计:
- Web层从Flask换成Flask + uvicorn worker?不行。Flask是WSGI,天生同步。要么整个迁到FastAPI/Starlette,要么用
asgiref的async_to_sync在Flask里跑协程——后者是伪异步,一个worker里还是串行处理请求,治标不治本。
我选择了最小改动方案:保留Flask做路由和参数校验,但把耗时的聚合逻辑抽成一个独立的asyncio服务层,Web层通过一个常驻的event loop提交任务。实际落地时更干脆——直接把接口层换成FastAPI,因为改造成本差不多,而FastAPI原生async更干净。下面代码用FastAPI展示,这也是我最终上线的版本。
-
下游调用统一用aiohttp的
ClientSession,全局单例,配连接池:TCPConnector(limit=200, limit_per_host=50)。 -
用
asyncio.gather并发四个调用,加asyncio.Semaphore限制单接口并发度,防止突发流量打穿下游。 -
每个下游调用包一层
asyncio.wait_for做超时,超时的下游降级返回默认值,不让整个请求失败。 -
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等待。几个可复用的经验:
- 判断要不要异步,看CPU利用率。低于30%且延迟高,基本是IO瓶颈,异步收益大。
ClientSession、Redis连接、信号量这些必须全局单例,在lifespan里管理生命周期。- 异步函数里禁止同步IO,这是最容易犯也最难查的错,
py-spy是排查利器。 - worker数不是越多越好,每个worker独立连接池,要按下游承载能力反推。
- 降级和超时要分层设计,单下游超时不能拖垮整个请求。
最后提醒一句:asyncio不是银弹。如果下游是CPU密集或者有强依赖链,异步帮不上忙。但如果你的接口像我这个一样,是一堆互不依赖的IO拼接,那改造收益会非常直接。