《AI Agent 技术原理与架构·运行时、协议与系统架构》3.2 并发上限、背压与取消

消费者跟不上时,无界队列会无限积压,有界队列让生产者等待——这就是背压。实验模拟三种模式的生产—消费,统计最大积压,并用取消令牌演示任务在执行前就能被放弃。结论是并发上限要设,背压要把积压限制在容量内,取消要能传播到尚未执行的任务。背压的本质不是拒绝,而是用有限队列把生产速率压到与消费速率匹配,让积压有上界。

以下生产速率、消费速率、容量数字均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。生产每 2 tick、消费每 3 tick 的速率只用于演示"消费者跟不上",真实系统按实测吞吐配容量,但"无界队列会无限积压"这一条不变。

3.1 讲了队列怎么排。这一节问:队列有多深?以及消费者跟不上时怎么办?这两个问题合起来就是并发控制的核心:并发上限、背压、取消。

一个 Agent 系统同时收进大量请求,但它们消费不掉,就会积压。积压不可怕,可怕的是无限积压——内存被拖垮、任务在队列里过期、故障被掩盖。这一节把积压变成一个可以量化的量,并演示两种控制手段:有界队列(背压)和取消令牌。

无界队列为什么危险

生产—消费模型里,生产比消费快,队列就会变长。如果队列无界,积压没有上限。

问题无界队列的表现
内存积压任务无限吃内存,直到 OOM
延迟任务在队列里越等越久,消费时已过期
故障掩盖下游故障被积压掩盖,看起来"都在排队"

积压的第三个问题最隐蔽:当下游变慢,无界队列会继续收任务,表面上是"队列在排",实际上系统的延迟和内存都在恶化。等到问题暴露,已经积压了几千个任务。

背压:让生产者等待

背压的思路是把队列变有界:容量固定,队列满时生产者被阻塞(任务不进入队列),等有空位再放。

模式队列生产者积压
无界无限从不等待无限增长
有界容量 C满时等待限制在 C 以内

背压的代价是生产者可能阻塞——用户请求被挂在门口。但这是对的:与其让任务积压到 OOM,不如在入口就限流,让用户明确知道"现在放不下"。 背压把"隐性的无限积压"变成"显性的有限等待"。

取消:在执行前放弃

第三个问题是取消。用户取消了请求,或者任务已经没意义,还在队列里排队。取消令牌(cancellation token)让任务在执行前就能检查"我还该不该做":

  1. 任务进入队列时带上令牌;
  2. 执行前检查令牌,已取消则跳过;
  3. 执行中的任务若支持取消,中止并回滚(见 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']

三行输出对应三个场景:

  1. unbounded:max_backlog=7, final=6。生产比消费快,队列积压到 7 且最终仍积压 6。如果 tick 数拉长,积压会继续涨——无界队列没有上限。
  2. bounded2(capacity=2):max_backlog=2, final=1。同样的速率,有界队列把最大积压限制在 2,结束时积压只剩 1。积压从"无限增长"变成"限制在容量内",代价是生产者被背压阻塞。
  3. 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 长任务、定时任务与延迟任务 。

常见错误与边界

  1. 用无界队列。 任何无界积压都会在高峰期变成 OOM 或无限延迟;容量必须显式配置。
  2. 背压只写文档不实现。 满时继续收任务等于没有背压;要真在入口阻塞生产者。
  3. 取消只作用于发起处。 不传播的取消令牌等于没有;下游任务仍会执行过期请求。
  4. 执行中任务不响应取消。 取消后任务还在跑(甚至产生副作用),需要配合补偿机制(见 5.3)。
  5. 以为有界就能清空。 有界只保证积压不超容量,不保证最终为零;容量按峰值吞吐配。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图