以下生产速率、消费速率、容量数字均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。生产每 2 tick、消费每 3 tick 的速率只用于演示"消费者跟不上",真实系统按实测吞吐配容量,但"无界队列会无限积压"这一条不变。
3.1 讲了队列怎么排。这一节问:队列有多深?以及消费者跟不上时怎么办?这两个问题合起来就是并发控制的核心:并发上限、背压、取消。
一个 Agent 系统同时收进大量请求,但它们消费不掉,就会积压。积压不可怕,可怕的是无限积压——内存被拖垮、任务在队列里过期、故障被掩盖。这一节把积压变成一个可以量化的量,并演示两种控制手段:有界队列(背压)和取消令牌。
无界队列为什么危险
生产—消费模型里,生产比消费快,队列就会变长。如果队列无界,积压没有上限。
| 问题 | 无界队列的表现 |
|---|---|
| 内存 | 积压任务无限吃内存,直到 OOM |
| 延迟 | 任务在队列里越等越久,消费时已过期 |
| 故障掩盖 | 下游故障被积压掩盖,看起来"都在排队" |
积压的第三个问题最隐蔽:当下游变慢,无界队列会继续收任务,表面上是"队列在排",实际上系统的延迟和内存都在恶化。等到问题暴露,已经积压了几千个任务。
背压:让生产者等待
背压的思路是把队列变有界:容量固定,队列满时生产者被阻塞(任务不进入队列),等有空位再放。
| 模式 | 队列 | 生产者 | 积压 |
|---|---|---|---|
| 无界 | 无限 | 从不等待 | 无限增长 |
| 有界 | 容量 C | 满时等待 | 限制在 C 以内 |
背压的代价是生产者可能阻塞——用户请求被挂在门口。但这是对的:与其让任务积压到 OOM,不如在入口就限流,让用户明确知道"现在放不下"。 背压把"隐性的无限积压"变成"显性的有限等待"。
取消:在执行前放弃
第三个问题是取消。用户取消了请求,或者任务已经没意义,还在队列里排队。取消令牌(cancellation token)让任务在执行前就能检查"我还该不该做":
- 任务进入队列时带上令牌;
- 执行前检查令牌,已取消则跳过;
- 执行中的任务若支持取消,中止并回滚(见 5.3 补偿)。
取消的重点是传播:令牌不是某个任务自己的私有标志,而是从请求发起处一路传到所有可能执行它的地方。取消了一个请求,所有排队等它的下游任务都要看到同一个信号。
最小实验:三种模式 + 取消令牌
实验做两件事:用生产(每 2 tick)消费(每 3 tick)的离散模拟跑无界与有界两种模式,统计最大积压;再用取消令牌演示取消传播。
# file: agp_lab/backpressure.py | write
# tier: 3
# verify: python3 -m unittest tests.test_backpressure
"""并发上限、背压与取消。
消费者跟不上时,无界队列会无限积压;有界队列让生产者
等待(背压),把积压限制在容量内。取消令牌则让任务在
执行前就能被放弃。
本模块模拟三种模式的生产—消费,统计最大积压,
并演示取消令牌的传播。
"""
from __future__ import annotations
from collections import deque
from dataclasses import dataclass
from typing import Any
@dataclass
class CancelToken:
cancelled: bool = False
def cancel(self) -> None:
self.cancelled = True
def simulate(mode: str, capacity: int | None = None, ticks: int = 40) -> dict[str, int]:
"""生产(每 2 tick 一个)消费(每 3 tick 一个)的离散模拟。
mode 取值:
- "unbounded":无界队列,生产者从不等待;
- "bounded" :容量受限,满时生产者被背压,等待空闲;
- "cancel" :与 bounded 相同,仅供对比。
"""
queue: deque[str] = deque()
backlog: list[int] = []
produced = 0
consumed = 0
for tick in range(ticks):
if tick % 2 == 0:
if mode == "bounded" and capacity is not None and len(queue) >= capacity:
pass # 背压:生产者被阻塞,任务不进入队列
else:
queue.append(f"t{produced}")
produced += 1
if tick % 3 == 0 and queue:
queue.popleft()
consumed += 1
backlog.append(len(queue))
return {
"max_backlog": max(backlog),
"final_backlog": backlog[-1],
"produced": produced,
"consumed": consumed,
}
def cancellation_demo() -> dict[str, Any]:
"""取消令牌:取消后不再执行后续任务。"""
token = CancelToken()
executed: list[str] = []
results: dict[str, str] = {}
def run(name: str) -> str:
if token.cancelled:
return "skipped"
executed.append(name)
return "done"
results["a"] = run("a")
token.cancel()
results["b"] = run("b")
results["c"] = run("c")
return {"results": results, "executed": executed, "cancelled": token.cancelled}
def demo() -> dict[str, Any]:
return {
"unbounded": simulate("unbounded"),
"bounded2": simulate("bounded", capacity=2),
"cancellation": cancellation_demo(),
}
if __name__ == "__main__":
for name, result in demo().items():
if name == "cancellation":
print(f"cancellation results={result['results']} executed={result['executed']}")
else:
print(f"{name:<10} max_backlog={result['max_backlog']} final={result['final_backlog']}")
运行:
cd private/labs/agp-lab
python3 -m agp_lab.backpressure
输出:
unbounded max_backlog=7 final=6
bounded2 max_backlog=2 final=1
cancellation results={'a': 'done', 'b': 'skipped', 'c': 'skipped'} executed=['a']
三行输出对应三个场景:
- unbounded:max_backlog=7, final=6。生产比消费快,队列积压到 7 且最终仍积压 6。如果 tick 数拉长,积压会继续涨——无界队列没有上限。
- bounded2(capacity=2):max_backlog=2, final=1。同样的速率,有界队列把最大积压限制在 2,结束时积压只剩 1。积压从"无限增长"变成"限制在容量内",代价是生产者被背压阻塞。
- cancellation:a 完成,b、c 跳过。任务 a 执行后令牌被取消,后续的 b、c 在执行前检查到已取消,返回 skipped。只有 a 真正执行过。这就是取消传播:一个令牌,所有后续任务一起看见。
一个值得点破的细节:bounded2 的 final=1 而不是 0,说明积压没有完全清空——有界队列只保证"不超过容量",不保证"最终清空"。生产端偶尔比消费端快是正常的,关键是积压有上限,不会失控。
背压参数(队列容量)的设定,本质上是一次容量规划。容量太小,正常波动也会触发背压,用户请求被不必要地拒绝;容量太大,又回到无界积压的老问题。容量要与生产/消费速率匹配,而不是拍脑袋定一个数。
一个实用的调参方法是:用实验里的模拟器,输入实测的生产速率和消费速率,扫一遍容量,观察最大积压曲线。找到"积压开始失控"的拐点,把容量设在拐点以内。这个做法把背压从玄学变成可测量。
取消语义也要和副作用对齐。 取消令牌跳过尚未执行的任务,但已经执行了一半的副作用(比如已经写了一半的文件)需要补偿机制配合(见 5.3)。只做"执行前检查"的取消,解决的是"别浪费资源",解决不了"已经发生的副作用"。所以取消语义要分两层:队列层的跳过,执行层的补偿。
背压在实践中要沿链路逐层传递,不只是最后一层。一个请求经过"网关 → 会话管理 → 执行引擎 → 工具调用",如果只在执行引擎出口加背压,网关和会话层仍会无界接包——源头不停,中间层迟早积压。正确的做法是每层都能向上游传递"我满了"的信号:
| 层级 | 背压载体 | 满时的表现 |
|---|---|---|
| 网关 | 返回 429 | 客户端感知,自行退避 |
| 会话层 | 拒绝新会话 | 用户等待或降级 |
| 执行引擎 | 队列满丢新任务 | 任务在源头被拒 |
| 工具层 | 慢速放行 | 响应变慢但不堆积 |
背压与限流是两件事。 背压是"我扛不住,慢下来",限流是"配额用尽,拒绝"。背压信号是动态的、逐层的;限流是静态的、入口处的。一个系统通常两层都用:入口限流防突发打爆,链路背压保局部不崩。
背压策略还要处理"什么时候解除"。 背压不是永久拒绝,是"现在放不下、等会再放"。解除的机制通常跟着队列水位走:水位回落到阈值以下,重新接收请求。但回落阈值要设得低于触发阈值,否则在高频波动下背压反复开关(抖动),客户端不停重试——用滞后(hysteresis)让背压有开关余量。
| 参数 | 作用 | 调整风险 |
|---|---|---|
| 触发水位 | 何时开始拒绝 | 太低→正常波动误拒 |
| 回落水位 | 何时恢复接收 | 太高→反复开关抖动 |
| 拒绝间隔 | 两个 429 之间多久 | 太密→客户端饿死 |
背压与监控联动才有意义:背压触发时要能看到"哪个队列满了、持续多久、拒绝了多少"。这些指标帮助判断——是持续过载(要扩容),还是瞬时冲击(容量够,策略正确)。
背压的量化收益来自"拒绝得快"。 一个请求在队列里等 10 秒才被拒绝,比立即拒绝浪费了更多资源——等待本身占着任务槽、占着会话状态。所以背压不只是"拒绝",还要"早拒绝":在请求进入昂贵路径(执行、工具调用)之前就判断水位,而不是让它进队列等半天再弹出来。
| 拒绝时机 | 浪费 | 例子 |
|---|---|---|
| 入口立即拒绝 | 最少 | 429 秒回 |
| 队列中等候后拒绝 | 中 | 等 10 秒才拒 |
| 执行中途超时 | 最多 | 跑了再失败 |
“早拒绝"与"尽最大努力排队"的取舍要看业务:交互场景宁可早拒绝让用户重试,批处理场景宁可排队等资源。背压策略里加一个"最长等待时间”,超过就放弃——把"拒绝"从被动变成主动的预算管理。
架构判据
并发控制是否合格,用五条判据检查:
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 队列有界 | 容量明确,积压有上限 | 无界队列,积压无上限 |
| 背压生效 | 满时生产者等待而非无限入队 | 满时仍继续收任务 |
| 取消传播 | 令牌从发起处传到所有下游 | 取消只作用于发起处 |
| 执行前检查 | 任务执行前检查取消标志 | 取消对已排队任务无效 |
| 可观测 | 积压、等待、取消可统计 | 并发状态黑盒 |
判据第一条"队列有界"是硬门槛:无界队列在任何 Agent 运行时都是不可接受的。 其它判据衡量的是背压和取消是否真的落实,而不只是写在文档里。
小结
- 无界队列会无限积压,同时恶化内存、延迟并掩盖故障;积压必须限制在容量内。
- 背压让生产者等待,把隐性无限积压变成显性有限等待。
- 取消令牌从请求发起处传播到所有下游,任务执行前检查并跳过已取消者。
- 实验量化了三件事:无界积压到 7、有界限制到 2、取消让 b/c 跳过只执行 a。
阅读导航:上一节:3.1 队列、优先级与公平调度 · 下一节:3.3 长任务、定时任务与延迟任务 。
常见错误与边界
- 用无界队列。 任何无界积压都会在高峰期变成 OOM 或无限延迟;容量必须显式配置。
- 背压只写文档不实现。 满时继续收任务等于没有背压;要真在入口阻塞生产者。
- 取消只作用于发起处。 不传播的取消令牌等于没有;下游任务仍会执行过期请求。
- 执行中任务不响应取消。 取消后任务还在跑(甚至产生副作用),需要配合补偿机制(见 5.3)。
- 以为有界就能清空。 有界只保证积压不超容量,不保证最终为零;容量按峰值吞吐配。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。