📌 TL;DR
max_concurrency设 1 就等于串行 。同一批 4 条请求实测:并发 1 → 3.79s,并发 6 → 1.41s。这证明batch真在并发,不是循环。但提速非线性(总耗时≈最慢那条),且超过请求数再加大毫无意义。asyncio.gather默认"一条失败全盘皆输" 。生产里必须加return_exceptions=True,否则 9 条成功的结果也拿不到,token 白烧。- 配额治理要三层叠加 :限流(信号量/
max_concurrency)+ 退避(指数 0.5→1→2→4)+ 熔断(超预算即停)。缺一层,某天半夜就会炸。
本篇代码踩了 3 个只在 Windows + httpx 上才出现的坑,包括"关掉一个模型的异步客户端,另一个也发不出请求了"------原因很反直觉,见第七节。
一、上一篇留下的三个问题
篇 12 只说了"batch 比 for 循环快 2.7 倍",回答了一半,留下三个更要命的:
- 并发开多大合适?开太大会怎样?
asyncio.gather和batch有什么区别?- 撞上 429 限流之后怎么办?
这一篇全部回答。先给结论:
并发不是"越大越好",而是"限住上限 + 撞了会退避 + 超预算会熔断"。
二、max_concurrency:并发度到底怎么控
它是通过 config 传的
model.batch(questions, config={"max_concurrency": 3})
不是位置参数,很多人找不到它就是因为这个。
| 取值 | 实际行为 |
|---|---|
1 |
完全串行,等同 for 循环 |
3 |
3 个一起飞,其余排队 |
≥ 请求数 |
全部一起飞(等于不限流) |
实测:同一批 4 条,只改并发度

max_concurrency= 1 → 3.79s ← 等于串行
max_concurrency= 3 → 2.04s ← 提速 1.86 倍
max_concurrency= 6 → 1.41s ← 提速 2.68 倍
从这组数据读三个结论
结论一:并发度 1 = 串行,这就是"batch 不是 for 循环"的反证。
如果 batch 只是循环,那并发度设多少都该一样。实测差 2.7 倍,说明它真在并发。
结论二:提速不是线性的。
4 条请求,理论上该快 4 倍,实际 2.68 倍。原因:
- 总耗时 ≈ 最慢的那一条,不是平均值
- 请求发出有调度开销
- 网络抖动,总有一条特别慢
结论三:超过请求数之后再加大,完全没有意义。
4 条请求,并发 6 和并发 4 完全一样------没有第 5、6 条可以飞。这是个很常见的无效配置。
实践建议:4~8
为什么不建议开更大?
因为平台的限流阈值通常是个位数到十几 。你开 20,前几个过了,后面全被 429 拒,然后你要重试------总耗时反而更长。
一个反直觉的事实:
并发从 8 加到 20,吞吐可能不升反降,因为大量请求在"被拒→退避→重试"里空转。
稳妥策略:从 4 开始,观察有没有 429;没有慢慢加,一旦出现就退回来。
三、asyncio.gather:batch 做不了的事
为什么 batch 不够
batch 只能处理"同一件事、不同输入"。
但真实业务常是"不同的事同时做":
- 同时查天气、股票、新闻(三个不同工具)
- 同让两个模型各写一版文案再挑
- 同时读三个文件
batch 做不了,因为它要求输入是"同类型的一批"。这时用 gather。
三种写法实测
# 方式一:顺序 await(串行)
for q in questions:
await model.ainvoke(q) # 3.87s
# 方式二:asyncio.gather(并发)
await asyncio.gather(*[model.ainvoke(q) for q in questions]) # 1.23s,快 3.15 倍
# 方式三:model.abatch(LangChain 封装)
await model.abatch(questions, config={"max_concurrency": 4}) # 1.14s

gather 的关键特性:结果顺序
gather 返回的列表,顺序 = 传入顺序,不是"完成先后"。
results = await asyncio.gather(*[slow_task(), fast_task()])
# results[0] 一定是 slow_task 的结果,哪怕它后完成
这个设计很重要------否则你拿到一堆结果,却不知道哪条对应哪个输入。
⚠ 默认行为:一条失败,全盘皆输
results = await asyncio.gather(*tasks)
# 10 条里 1 条挂了 → 整体抛异常 → 另外 9 条成功的结果也拿不到
这在生产里是灾难:token 已经花了,结果却丢了。
必须加 return_exceptions=True:
results = await asyncio.gather(*tasks, return_exceptions=True)
for r in results:
if isinstance(r, Exception):
print("这条失败:", r)
else:
print("成功:", r)
失败变成"结果的一部分",而不是中断整批。这是 gather 最该记住的一个参数。
三者怎么选
| 需求 | 选择 |
|---|---|
| 多条同类请求,要省事 | model.abatch |
| 并发里要穿插自己的逻辑 | asyncio.gather |
| 并发里要精确控制上限 | gather + Semaphore |
四、信号量:把并发"精确"卡住
为什么 max_concurrency 还不够
max_concurrency 只能限制"这一次 batch"。
但真实系统里并发来自很多地方:定时任务、多个用户请求、多个 batch 同时在跑。它们各自限流,加起来就超了。
这时需要一个全局的、跨调用的限制器------信号量。
原理:停车场的道闸
只有 3 个车位:车位满 → 新车排队;有车走 → 放一辆进来。
sem = asyncio.Semaphore(3)
async def worker(q):
async with sem: # 拿到一个"车位"才能进
return await model.ainvoke(q)
# 出 with 块自动"还车位"
关键:async with sem 保证同一时刻最多 3 个协程进入。 其余自动排队,不需要写任何等待逻辑。
实测:信号量真的限住了吗
光"代码看起来对"不够,要实测峰值并发。方法:计数器记录"当前几个在飞、历史最高几个"。
信号量容量 总耗时 实测峰值并发 结果条数
1 9.31s 1 10
3 4.13s 3 10
5 2.49s 5 10
峰值并发严格等于信号量容量 ------ 限流确实生效了。
对照组(不用信号量,10 条全发):
耗时 1.72s,峰值并发 10
确实更快,但峰值 10 个同时在飞,这正是撞限流的姿势。省下的 0.7 秒,可能要用"全批失败 + 重试"来还。
一个容易忽略的点:计数器本身要加锁
async def enter(self):
async with self.lock: # ← 这里也必须锁
self.now += 1
self.peak = max(self.peak, self.now)
不加锁会怎样?两个协程同时读到 now=2,各自加 1 写回 3,实际应该是 4。峰值统计就偏小了------让你误以为限流生效了,其实没有。
凡是"读-改-写"的共享状态,在并发下都要加锁。 这是基本功。
还有一层:连接池
httpx.AsyncClient 内部有连接池。你并发 50,但池子只有 20 条连接,剩下 30 个在排队等连接------这时你会困惑:"明明设了 50 并发,为什么只跑到 20?"
光调大 max_concurrency 不一定有效,可能卡在连接池。 知道这一层存在,能省很多排查时间。
五、配额治理:三层叠加

第 1 层:成本核算
每次调用后读 token 用量:
usage = result.response_metadata["token_usage"]
# {"prompt_tokens": 12, "completion_tokens": 3, "total_tokens": 15}
注意输入输出分开算------单价不同,输出通常更贵。
第 2 层:熔断
if budget.exhausted:
print("预算用尽,熔断")
break
为什么需要熔断?
一次跑飞可能是几万条请求。你不希望"等账单来了才知道",你希望"跑到 3000 token 自己停"。
真实案例:有人循环本意跑 100 条,条件写错变成死循环,一晚上烧掉几百块。有熔断就只是一顿饭钱。
第 3 层:重试必须指数退避
撞 429 不能立刻重试------立刻重试 = 继续加压 = 更严重地被限流。这叫重试风暴,是压垮服务的经典原因。
正确做法:
第 1 次失败 → 等 0.5s
第 2 次失败 → 等 1s
第 3 次失败 → 等 2s
第 4 次失败 → 等 4s
每次翻倍,给服务端喘息时间,也降低自己再次命中的概率。
只重试「可恢复」的错误
这条最关键:不是所有错误都值得重试。
| 错误 | 可重试 | 原因 |
|---|---|---|
| 429 限流 | ✅ | 等一会儿就好 |
| 超时 | ✅ | 网络抖动 |
| 500/502/503 | ✅ | 服务端临时故障 |
| 400 参数错 | ❌ | 重试 100 次还是错 |
| 401 鉴权失败 | ❌ | Key 错了 |
| 404 模型不存在 | ❌ | 模型名拼错 |
对 400/401 做退避重试,纯粹浪费时间------还会让日志充满噪音,掩盖真正的问题。
实测:对 400 只尝试 1 次就抛出,不做任何退避。
单次成本极低,乘规模不是小数
实测 4 条短问题:
用掉 61/3000 tokens,成本约 ¥0.000074
按此推算,1 万次调用约 ¥0.19
单次连一分钱的万分之一都不到。但:
| 规模 | 成本(按此推算) |
|---|---|
| 1 万次 | ≈ ¥0.19 |
| 100 万次 | ≈ ¥19 |
| 1 亿次 | ≈ ¥1900 |
而且这是"短问题 + 短回答"。真实业务 prompt 动辄上千 token,成本要乘几十倍。
所以成本控制不是抠门,是工程必需。
六、踩坑排查
| # | 现象 | 真实原因 | 解法 |
|---|---|---|---|
| 1 | max_concurrency=1 时 batch 很慢 |
这本来就是串行 | 正常;并发度设 4~8 |
| 2 | 并发加到 20,吞吐反而降 | 撞限流,大量请求在重试 | 退回 4~8 + 退避 |
| 3 | gather 一条失败全部失败 |
默认不捕获异常 | return_exceptions=True |
| 4 | 峰值并发统计偏小 | 计数器 += 不加锁 |
用 asyncio.Lock |
| 5 | 跑一会儿卡死不报错 | 信号量没在 finally 归还 |
try/finally: release() |
| 6 | 成本估算低于账单很多 | 只算输出 token,漏了输入 | 输入输出分开算 |
| 7 | 对 400 重试 4 次还是失败 | 参数错重试无意义 | 只重试 429/超时/5xx |
七、三个只在"跑起来"才发现的坑
这一节的三个问题全是真实报错,共同点是:文档查不到,只能跑出来。
坑 1:Windows 上 RuntimeError: Event loop is closed
最初写成:
asyncio.run(demo2_asyncio_gather())
asyncio.run(demo3_semaphore()) # ← 这里崩
原因 :asyncio.run() 每次都新建并关闭 一个 loop。httpx 关闭异步连接时,要把清理回调通过 loop.call_soon() 挂回创建它的那个 loop。演示 2 的 loop 已经关了,回调挂不上去就抛错。
Windows 的 ProactorEventLoop 尤其容易触发。
修复(两手都做):
# ① Windows 换 SelectorEventLoop
if sys.platform == "win32":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
# ② 所有异步演示放进同一个 asyncio.run()
asyncio.run(_async_demos())
坑 2:'AsyncCompletions' object has no attribute 'close'
想主动关客户端,写了 await model.async_client.close(),报 AttributeError。
实测四个属性的真实类型:
| 属性 | 类型 | 有 close() |
|---|---|---|
model.async_client |
AsyncCompletions |
❌ |
model.root_async_client |
AsyncOpenAI |
✅ |
model.client |
Completions |
❌ |
model.root_client |
OpenAI |
✅ |
修复 :用 root_async_client。
坑 3:关掉一个模型的客户端,另一个也发不出请求了
这是最反直觉的一个。修好坑 2 后,在演示 2、3 各 close() 一次,演示 3 第一个请求就崩:
RuntimeError: Cannot send a request, as the client has been closed.
原因 :langchain-openai 会按参数缓存底层的 httpx.AsyncClient。实测验证:
两个实例是否同一个 root_async_client: False
底层 httpx 是否同一个: True ← 关键
也就是说:
a = ChatOpenAI(**same_kwargs)
b = ChatOpenAI(**same_kwargs)
await a.root_async_client.close() # 关的是共用连接池
await b.ainvoke("...") # → 报错,池子没了
包装对象是新的,连接池是共用的。
修复 :所有异步请求结束后,统一只关一次。
三个坑的共同教训
框架的"默认行为"和"文档描述"之间,常有一段只有跑起来才看得见的距离。
- 文档不会告诉你 Windows 的 Proactor loop 有关闭问题
- 文档不会告诉你
async_client不是 HTTP 客户端 - 文档不会告诉你连接池是跨实例共享的
这三条都不难,但不跑就永远不知道。这也是我坚持"代码是源"的原因------先跑通,再写文档;跑不通的代码,写出来的文档一定错。
八、面试常考六问
Q1:batch 一定比 for 循环快吗?
不一定。max_concurrency=1 时就是串行,和 for 一样。且请求间有依赖时根本不能用 batch。
Q2:gather 里一条失败会怎样?
默认整体抛异常 ,其他成功的结果全部丢失。必须加 return_exceptions=True。
Q3:并发越大吞吐越高吗?
不是。超过平台阈值后,大量请求在"被拒→退避→重试"里空转,吞吐反而下降。
Q4:max_concurrency 和信号量有什么区别?
前者只作用于"这一次 batch";后者是全局、跨调用的。多来源并发时要靠信号量。
Q5:为什么重试必须指数退避?
立刻重试 = 继续加压 = 更严重限流(重试风暴)。退避给服务端喘息时间,也降低再次命中的概率。
Q6:哪些错误不该重试?
400 参数错、401 鉴权失败、404 资源不存在。重试再多次结果一样,只浪费配额和日志。
九、本篇小结
| 概念 | 一句话 |
|---|---|
max_concurrency |
通过 config 传;1 = 串行,4~8 是安全区 |
| 提速非线性 | 总耗时 ≈ 最慢那条,不是平均值 |
gather |
手写并发;结果顺序 = 传入顺序 |
return_exceptions |
让失败变成结果,别毁掉整批 |
Semaphore |
全局限流,async with sem 自动排队 |
| 计数器加锁 | 读-改-写不是原子操作 |
| 连接池 | 底层还有一层隐式限流 |
| 熔断 | 超预算即停,不等账单 |
| 指数退避 | 0.5→1→2→4,越等越久 |
| 只重试可恢复错误 | 429/超时/5xx 重试;400/401 立刻抛 |
| 三层治理 | 限流 + 退避 + 熔断,缺一不可 |
如果只能记一句话:
并发不是"越大越好",而是"限住上限 + 撞了会退避 + 超预算会熔断"。
十、完整代码
完整可运行代码已上传至 Gitee(01_模型接入_LangChain/13_concurrency.py):
[13_concurrency.py](https://gitee.com/A1328585346/pracote-lang-chain--lang-graph/blob/master/01_模型接入_LangChain/13_concurrency.py)
含 4 个演示、完整注释、以及上述三个 Windows/httpx 坑的修复代码与注释说明。
十一、下一篇预告
篇 14:ChatOpenAI 参数 / base_url / invoke
回到"模型本身",把参数讲透:
temperature/top_p到底怎么影响输出max_tokens设小了会怎样(答案被截断但不报错)timeout/max_retries该怎么配(生产必需)base_url支持的几种写法(Azure / 代理 / 本地 Ollama)
系列导航 :本系列按「两小时套餐」推进------第一小时讲透原理与坑点,第二小时给可跑通代码。目前已更新至第 13 篇。
相关篇目 :篇 12(
batch/stream基础,本篇回答它留下的三个问题)、篇 15(错误处理与重试,会深挖本篇提到的退避与熔断)。