[LangChain] 学习笔记(13):并发不是越大越好——batch / gather / 信号量 / 配额治理

📌 TL;DR

  1. max_concurrency 设 1 就等于串行 。同一批 4 条请求实测:并发 1 → 3.79s,并发 6 → 1.41s。这证明 batch 真在并发,不是循环。但提速非线性(总耗时≈最慢那条),且超过请求数再加大毫无意义。
  2. asyncio.gather 默认"一条失败全盘皆输" 。生产里必须加 return_exceptions=True,否则 9 条成功的结果也拿不到,token 白烧。
  3. 配额治理要三层叠加 :限流(信号量/max_concurrency)+ 退避(指数 0.5→1→2→4)+ 熔断(超预算即停)。缺一层,某天半夜就会炸。

本篇代码踩了 3 个只在 Windows + httpx 上才出现的坑,包括"关掉一个模型的异步客户端,另一个也发不出请求了"------原因很反直觉,见第七节。


一、上一篇留下的三个问题

篇 12 只说了"batch 比 for 循环快 2.7 倍",回答了一半,留下三个更要命的:

  1. 并发开多大合适?开太大会怎样?
  2. asyncio.gather 和 batch 有什么区别?
  3. 撞上 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(错误处理与重试,会深挖本篇提到的退避与熔断)。

相关推荐
渣渣盟1 小时前
狂命爆肝99天,共52K字的JAVA学习笔记奉上,JAVA从入门到精通一文搞定,一文在手JAVA无忧
java·笔记·学习
叼烟扛炮12 小时前
[LangChain] 学习笔记(09):工具(Tool)定义与调用闭环 · 理论+实战完整版
笔记·学习·langchain
个 人 练 习 生12 小时前
C++:从零基础到深入了解vector的使用
开发语言·c++·经验分享·学习·程序人生·stl
Rabitebla13 小时前
【Linux操作系统】 文件篇(一):文件描述符与 Linux 文件管理机制
linux·网络·c++·笔记·学习
Flying Bear15 小时前
Keithley 2450 SourceMeter源表上位机开发笔记
笔记·单片机·嵌入式硬件
旖旎夜光16 小时前
【C++ 基础入门】智能指针:RAII、unique_ptr 与 shared_ptr 循环引用
c++·笔记·学习·智能指针
饮水桶_T17 小时前
Python 面向对象(十七)|继承、封装、多态 笔记
数据结构·笔记·算法
星恒随风18 小时前
MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解——InnoDB 如何实现事务隔离?
linux·数据库·笔记·sql·mysql
zdr尽职尽责18 小时前
终端工具凭空消失:Codex + GPT-6 的一次完整排障复盘
数据库·gpt·学习·ai