返回专栏
· 30 分钟阅读

异步任务、队列与流量控制


一、为什么 AI 服务需要异步任务与队列

传统 Web 服务通常采用同步请求模型:客户端发送请求,服务端执行逻辑,完成后返回结果。

对于普通 CRUD 接口,这种模式通常足够简单。但 AI 服务的执行过程往往更加复杂。

一次 AI 请求可能涉及:

  • 模型推理:调用大语言模型生成内容。
  • RAG 检索:查询向量数据库、全文检索系统。
  • 文档解析:提取 PDF、Word、图片中的文本。
  • 多模态处理:图像识别、语音转写、视频分析。
  • Agent 执行:多轮模型调用、工具调用和结果验证。
  • 批量任务:批量生成 Embedding、摘要或分类结果。

这些任务通常具有以下特点:

  1. 执行时间不确定:模型推理可能持续几秒甚至数分钟。
  2. 资源消耗不均衡:不同请求消耗的 GPU 显存、CPU 和网络资源差异很大。
  3. 突发流量明显:用户可能在短时间内集中提交大量任务。
  4. 执行过程复杂:任务可能需要重试、暂停、恢复或人工干预。
  5. 结果不一定立即需要:用户可以先提交任务,稍后查询执行结果。

如果所有任务都采用同步方式处理,系统很容易出现请求超时、线程耗尽、GPU 过载和级联故障。

因此,需要引入三个核心机制:

机制 核心职责 解决的问题
异步任务 解耦提交与执行 长耗时请求阻塞
消息队列 缓冲、分发和调度 流量突发与生产消费不平衡
流量控制 限制进入系统的负载 资源过载与服务雪崩

三者不是彼此独立的功能,而是高并发 AI 服务中的一套协同机制。

二、同步执行与异步执行

2.1 同步执行

同步执行意味着请求方必须等待任务完成,才能获得最终结果。

典型过程:

flowchart TD
    A["客户端提交请求"] --> B["API 接收请求"]
    B --> C["执行模型推理"]
    C --> D["处理推理结果"]
    D --> E["返回最终响应"]
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F

同步模式的优势:

  • 实现简单。
  • 请求与结果天然关联。
  • 客户端可以直接获得执行结果。
  • 不需要额外的任务状态管理。

但它也有明显限制:

  • 请求连接需要持续占用。
  • 长时间推理会增加连接和线程资源消耗。
  • 客户端超时不代表服务端任务已经停止。
  • 高并发情况下容易耗尽服务端资源。
  • 不适合执行需要持续数分钟的复杂任务。

2.2 异步执行

异步执行将任务提交与任务处理分离。

客户端提交任务后,服务端只负责完成接收、校验、持久化和入队,然后立即返回任务 ID。

后台 Worker 从队列中获取任务并执行,客户端通过任务 ID 查询状态或接收通知。

flowchart TD
    A["客户端提交任务"] --> B["API 校验请求"]
    B --> C["创建任务记录"]
    C --> D["任务写入消息队列"]
    D --> E["返回 Task ID"]
    D --> F["Worker 获取任务"]
    F --> G["执行 AI 任务"]
    G --> H["保存执行结果"]
    H --> I["更新任务状态"]
    I --> J["客户端查询或接收通知"]
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

异步模式将原本由 API 请求线程承担的长时间执行工作转移到后台任务系统。

它特别适合:

  • 长文本生成。
  • 批量 Embedding 计算。
  • 大规模文档解析。
  • Agent 长周期任务。
  • 数据集生成和模型评估。
  • 视频、音频等多模态处理。

2.3 同步与异步如何选择

维度 同步执行 异步执行
返回方式 返回最终结果 先返回任务 ID
连接占用 持续等待 提交后即可释放
执行时间 适合较短任务 适合长耗时任务
状态管理 相对简单 需要任务状态管理
失败恢复 通常依赖请求重试 可通过队列和持久化恢复
系统复杂度 较低 较高
典型场景 短文本问答、实时对话 批量推理、文档处理、Agent

需要注意:异步不意味着一定要使用消息队列。后台线程、进程池和任务调度器也可以实现异步执行。但当系统需要跨服务通信、持久化、削峰填谷和故障恢复时,消息队列通常更合适。

三、异步任务的核心模型

异步任务不仅是把函数放到后台执行,还需要明确任务的生命周期、状态、执行权和结果管理方式。

3.1 任务的基本组成

一个完整的任务对象通常包含:

字段 作用
task_id 唯一任务标识
task_type 任务类型
payload 任务输入数据或数据引用
status 当前任务状态
priority 任务优先级
created_at 创建时间
started_at 开始执行时间
finished_at 完成时间
retry_count 已重试次数
max_retries 最大重试次数
timeout 任务超时时间
idempotency_key 幂等键
result_ref 执行结果存储位置
error 错误信息

任务对象示例:

{
  "task_id": "task_20261122_001",
  "task_type": "document_analysis",
  "payload": {
    "document_id": "doc_001"
  },
  "status": "queued",
  "priority": 5,
  "retry_count": 0,
  "max_retries": 3,
  "timeout": 600,
  "idempotency_key": "document_analysis_doc_001_v1"
}

对于大型文件和多模态任务,不建议直接将完整文件内容放入消息队列。

更合理的方式是:

  • 文件存储在对象存储中。
  • 数据库保存任务元数据。
  • 消息队列只传递任务 ID、文件地址和必要参数。

这样可以避免消息体过大,降低队列网络传输和存储压力。

3.2 任务生命周期

一个任务通常需要经历多个状态。

状态 含义
Pending 任务已经创建,尚未进入可执行队列
Queued 已进入队列,等待 Worker 获取
Running 正在执行
Retry Waiting 执行失败,等待重新执行
Succeeded 执行成功
Failed 已达到失败条件,无法继续执行
Cancelled 被用户或系统取消
Timeout 超过允许执行时间
Paused 暂停执行,等待恢复

状态流转示意:

flowchart TD
    A["Pending"] --> B["Queued"]
    B --> C["Running"]
    C --> D{"执行结果"}
    D -->|"成功"| E["Succeeded"]
    D -->|"可重试失败"| F["Retry Waiting"]
    D -->|"不可重试失败"| G["Failed"]
    D -->|"超时"| H["Timeout"]
    F --> I{"是否超过重试上限"}
    I -->|"否"| B
    I -->|"是"| G
    B --> J["Cancelled"]
    C --> K["Cancelled"]
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438

状态设计必须明确哪些转换合法。

例如:

  • Succeeded 不能重新变成 Running。
  • Cancelled 不应该被普通 Worker 自动重新执行。
  • Retry Waiting 必须受最大重试次数约束。
  • Timeout 与 Failed 可以根据业务定义为不同终态。
  • Running 任务如果 Worker 崩溃,需要有恢复机制。

任务状态不能仅依赖消息队列中的消息状态。 消息队列负责传递任务,数据库或持久化任务存储负责维护业务状态。两者需要通过一致性策略协同。

3.3 任务状态与消息状态的区别

两者经常被混淆。

任务状态 消息状态
描述业务执行进度 描述消息投递与消费进度
通常保存在数据库 通常由消息队列管理
包含 Running、Succeeded、Failed 包含 Ready、Unacked、Acknowledged 等
面向业务查询 面向消息传输与消费

例如,Worker 已经从队列获取消息,但模型推理还没有完成:

  • 消息可能处于未确认状态。
  • 业务任务已经处于 Running 状态。

如果 Worker 执行成功并确认消息,但任务结果没有可靠保存,就可能出现消息已消费、业务结果却丢失的问题。

因此,需要设计任务状态更新、结果持久化和消息确认之间的顺序。

四、消息队列的核心作用

消息队列是异步任务系统中的中间缓冲层。

它将任务生产者与任务消费者解耦,使任务提交速度和任务处理速度不必完全一致。

4.1 生产者与消费者

典型架构包含三个角色:

  • Producer:任务生产者,负责创建并发送任务。
  • Broker:消息代理,负责存储、路由和投递消息。
  • Consumer:任务消费者,负责获取消息并执行任务。
flowchart LR
    A["API 服务"] --> B["Producer"]
    B --> C["Message Broker"]
    C --> D["Worker 1"]
    C --> E["Worker 2"]
    C --> F["Worker 3"]
    D --> G["模型推理服务"]
    E --> G
    F --> H["文档处理服务"]
    G --> I["结果存储"]
    H --> I
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4.2 消息队列解决什么问题

第一,服务解耦。

API 服务不需要知道具体由哪个 Worker 执行任务,也不需要维护 Worker 的连接。

第二,削峰填谷。

当短时间内出现大量请求时,队列可以暂时保存任务,让消费者按照自身处理能力逐步执行。

第三,横向扩展。

可以根据任务积压情况增加 Worker 实例,提高整体处理能力。

第四,故障隔离。

某个消费者发生故障时,其他消费者可以继续处理任务,队列可以保留尚未完成的消息。

第五,任务分发。

不同类型的任务可以进入不同队列,由不同的 Worker 集群处理。

4.3 常见消息队列

技术 特点 常见使用场景
Redis Streams 轻量、支持消费组和消息确认 中小规模异步任务
RabbitMQ 路由能力丰富,支持确认机制 业务任务与复杂消息路由
Apache Kafka 高吞吐、持久化、分区机制成熟 大规模事件流和数据处理
Apache Pulsar 多租户、分层存储、消息与计算解耦 大规模分布式消息系统
Amazon SQS 托管队列,运维负担较低 云原生异步任务

选择消息队列时,不能只看吞吐量,还需要关注:

  • 消息持久化能力。
  • 消息确认机制。
  • 消费者失败后的恢复方式。
  • 消息顺序要求。
  • 延迟消息和死信队列支持。
  • 消费组与分区扩展能力。
  • 运维成本和可观测性。

4.4 队列模型

点对点队列(Queue)

一条消息通常由一个消费者成功处理,适合任务分发。

flowchart TD
    A["任务生产者"] --> B["任务队列"]
    B --> C["Worker A"]
    B --> D["Worker B"]
    B --> E["Worker C"]
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49

发布订阅(Pub/Sub)

一条事件可以被多个订阅者分别消费,适合事件广播。

flowchart TD
    A["事件生产者"] --> B["事件主题"]
    B --> C["订阅者 A"]
    B --> D["订阅者 B"]
    B --> E["订阅者 C"]
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49

需要注意,Kafka 的同一消费组内通常由一个消费者处理某个分区中的特定消息,而不同消费组可以独立消费同一主题的数据。这与简单的广播式 Pub/Sub 并不完全相同。

五、队列积压与削峰填谷

消息队列最重要的价值之一,是在生产速度和消费速度不一致时提供缓冲。

5.1 生产速度与消费速度

假设:

  • 每秒提交 100 个任务。
  • 每个 Worker 每秒处理 5 个任务。
  • 当前有 10 个 Worker。

整体处理能力:

\mu = 10 \times 5 = 50\ \text{tasks/s}

生产速度:

\lambda = 100\ \text{tasks/s}

队列积压增长速度:

\Delta Q = \lambda - \mu = 50\ \text{tasks/s}

如果持续 60 秒:

Q = 50 \times 60 = 3000

系统会积压约 3000 个任务。

队列只能暂时缓冲流量,不能无限吸收超过处理能力的请求。

5.2 队列长度与稳定性

定义:

  • \lambda:任务到达速率。
  • \mu:单个消费者的处理速率。
  • c:消费者数量。
  • Q:队列中的待处理任务数。

系统的理论处理能力:

C = c\mu

当:

\lambda < C

系统通常可以稳定处理任务,但还需要考虑处理时间波动、消费者故障和资源争用。

当:

\lambda > C

队列会持续增长。

当:

\lambda = C

系统处于临界状态,任何短时波动都可能造成积压。

因此,生产系统不应该长期运行在接近 100% 的理论处理能力上。

5.3 利用率与排队延迟

定义系统利用率:

\rho = \frac{\lambda}{c\mu}

当 \rho 越接近 1,排队延迟通常越容易显著增加。

对于简单的 M/M/1 排队模型:

W = \frac{1}{\mu-\lambda}

其中 W 是系统平均停留时间,包含等待和服务时间。

这个公式只适用于特定的理想排队假设,真实 AI 系统往往具有任务处理时间分布不均、优先级调度和资源竞争等复杂特征,不能直接用它精确预测生产延迟。

工程上更重要的是持续监控:

  • 队列长度。
  • 最老消息等待时间。
  • 任务到达速率。
  • 任务完成速率。
  • Worker 忙碌比例。
  • P95/P99 排队延迟。

5.4 估算队列排空时间

如果队列中有 10,000 个任务:

  • Worker 总处理能力:200 tasks/s。
  • 新任务到达速度:50 tasks/s。

净排空速度:

R = 200-50=150\ \text{tasks/s}

队列排空时间:

T = \frac{10000}{150}\approx66.7\ \text{s}

这可以用于估算系统恢复时间。

但如果新任务持续到达,排空速度必须使用消费能力减去到达速度,而不是直接使用消费者总处理能力。

六、流量控制的核心技术

流量控制的目标不是简单地拒绝请求,而是让系统在负载变化时维持可预测的延迟和稳定性。

常见技术包括:

  1. 限流(Rate Limiting)。
  2. 并发控制(Concurrency Limiting)。
  3. 背压(Backpressure)。
  4. 熔断(Circuit Breaker)。
  5. 降级(Degradation)。
  6. 优先级调度(Priority Scheduling)。
  7. 负载均衡(Load Balancing)。

这些技术分别控制不同层面的压力。

6.1 限流 Rate Limiting

限流限制单位时间内允许进入系统的请求数量。

例如:

  • 每个用户每秒最多提交 10 个请求。
  • 每个 API Key 每分钟最多提交 1000 个任务。
  • 整个服务每秒最多接收 500 个任务。

常见限流算法如下。

固定窗口(Fixed Window)

将时间划分为固定区间,每个区间单独计数。

例如,每分钟允许 100 次请求。

优点:

  • 实现简单。
  • 存储开销小。
  • 适合基础 API 配额控制。

缺点:

  • 存在窗口边界突发问题。

例如:

  • 10:00:59 提交 100 次。
  • 10:01:00 再提交 100 次。

短时间内可能实际收到 200 次请求。

滑动窗口(Sliding Window)

根据最近一段时间内的请求数量进行限制。

可以使用滑动日志或滑动计数器实现。

优点是比固定窗口更加平滑,但滑动日志会产生更高的存储和计算开销。

令牌桶(Token Bucket)

令牌按照固定速率生成,桶中最多保存一定数量的令牌。

每个请求需要消耗令牌才能通过。

核心参数:

  • r:令牌生成速率。
  • B:桶容量。
  • T:令牌数量。
  • \Delta t:经过时间。

令牌更新:

T_{\text{new}}=\min(B,T_{\text{old}}+r\Delta t)

请求到达时,如果令牌数量足够,就消耗令牌并放行;否则拒绝或等待。

flowchart TD
    A["请求到达"] --> B["检查令牌桶"]
    B --> C{"令牌是否充足"}
    C -->|"是"| D["消耗令牌"]
    D --> E["放行请求"]
    C -->|"否"| F{"是否允许等待"}
    F -->|"是"| G["进入等待队列"]
    F -->|"否"| H["返回限流响应"]
    G --> I["等待令牌补充"]
    I --> B
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

令牌桶允许短时间突发,但长期平均速率受到令牌生成速率限制。

漏桶(Leaky Bucket)

请求进入缓冲区,以固定速率流出。

它更强调平滑输出速度,适合限制下游服务的处理速率。

6.2 限流算法对比

算法 是否允许突发 主要特点 典型场景
固定窗口 窗口内允许集中请求 实现简单 基础配额
滑动窗口 相对平滑 精确控制时间范围 API 限流
令牌桶 允许有限突发 控制长期平均速率 API 网关
漏桶 输出速率较稳定 平滑流量 下游资源保护

对于 AI 服务,单纯按照请求数量限流往往不够。

因为不同请求的成本差异可能非常大:

  • 100 Token 的短问答。
  • 100,000 Token 的长上下文请求。
  • 一次多轮 Agent 执行。
  • 一次批量文档 Embedding。

这些请求虽然都只算一次 API 调用,但实际资源消耗完全不同。

因此,需要引入 Token 维度和资源维度的流量控制。

6.3 Token 级限流

大语言模型服务可以根据 Token 数量限制请求成本。

常见维度:

  • 输入 Token 数量。
  • 输出 Token 数量。
  • 输入与输出 Token 总量。
  • 每分钟 Token 数(TPM)。
  • 每秒 Token 数(TPS)。
  • 用户或租户的 Token 配额。

例如:

用户等级 RPM TPM
Free 10 20,000
Pro 60 100,000
Enterprise 300 1,000,000

这里的 RPM 表示 Requests Per Minute,TPM 表示 Tokens Per Minute,数值仅为示例。

Token 级限流需要特别注意:

  • 输入 Token 可以在推理前通过 Tokenizer 估算。
  • 输出 Token 数量通常无法在推理前准确确定。
  • 可以根据 max_tokens 预留预算。
  • 执行完成后再根据实际使用量结算。
  • 对超长上下文请求应单独设置限制。

对于流式生成,还可以在生成过程中持续检查 Token 预算,避免任务超出用户配额。

6.4 并发控制 Concurrency Limiting

限流控制单位时间内允许进入多少请求,并发控制限制同时执行的任务数量。

假设:

  • 每秒允许 100 个请求进入。
  • 每个请求平均执行 10 秒。

如果不限制并发,理论上可能同时存在约 1000 个执行中的请求。

但 AI 服务的 GPU 显存和推理能力有限,无法无限增加并发。

并发限制可以按不同资源维度配置:

限制维度 示例
全局并发 同时执行最多 200 个任务
用户并发 每个用户最多 5 个任务
模型并发 某模型最多 64 个并发请求
GPU 并发 每张 GPU 限制推理请求数
任务类型并发 文档解析最多 20 个任务
租户并发 每个租户独立资源配额

需要注意,并发数量不等于 GPU 实际批处理大小。

在大模型推理服务中,多个请求可以被连续批处理调度器动态组合,真正影响 GPU 资源的是请求长度、KV Cache 占用、批次 Token 数量和模型执行特征。

6.5 背压 Backpressure

背压是指下游处理能力不足时,将压力反馈给上游,阻止上游继续无限制地产生任务。

例如:

  • Worker 处理速度下降。
  • 队列积压持续增长。
  • 队列等待时间超过阈值。
  • 系统通知 API 降低接收速度。
  • API 延迟提交、拒绝新任务或降低任务优先级。

背压不是单纯的限流。

限流通常根据预设规则限制流量,而背压强调根据下游实时处理能力动态调整上游流量。

flowchart TD
    A["客户端提交任务"] --> B["API 服务"]
    B --> C["任务队列"]
    C --> D["Worker 集群"]
    D --> E["下游模型服务"]
    E --> F{"处理能力是否充足"}
    F -->|"是"| G["正常消费"]
    F -->|"否"| H["产生背压信号"]
    H --> I["降低生产速率"]
    I --> J["延迟接收或拒绝请求"]
    J --> B
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

常见背压策略:

  1. 队列达到阈值时暂停生产。
  2. 消费者处理速度下降时减少上游并发。
  3. 队列积压严重时拒绝低优先级任务。
  4. 对可延迟任务返回排队状态。
  5. 对无法等待的请求直接返回过载响应。

6.6 熔断 Circuit Breaker

当下游模型服务持续失败时,继续发送请求只会浪费资源。

熔断器根据失败率或超时情况,暂时停止向故障服务发送请求。

通常包含三个状态:

  • Closed:正常请求通过,同时统计失败情况。
  • Open:达到失败阈值,暂时拒绝请求。
  • Half-Open:等待一段时间后放出少量探测请求。
stateDiagram-v2
    [*] --> Closed
    Closed --> Open: 失败率超过阈值
    Open --> HalfOpen: 熔断等待结束
    HalfOpen --> Closed: 探测请求成功
    HalfOpen --> Open: 探测请求失败

熔断可以保护服务依赖,但需要合理设置:

  • 失败率阈值。
  • 统计窗口。
  • 最小请求样本数。
  • 熔断持续时间。
  • 半开状态探测请求数量。

如果下游服务只是短暂变慢,不一定需要立即熔断。可以结合超时、并发限制和负载情况共同判断。

6.7 降级 Degradation

当系统资源不足时,可以主动降低部分服务能力。

AI 服务常见降级策略:

故障或压力 降级策略
高质量模型过载 切换到轻量模型
GPU 资源不足 延迟执行非实时任务
长上下文过载 限制最大输入长度
RAG 检索异常 使用缓存结果或基础模型回答
Agent 工具不可用 返回部分结果或停止工具调用
队列积压严重 暂停低优先级任务
结果生成超时 返回已生成内容或任务状态

降级必须有明确的业务边界。

例如,不能在用户要求严格 JSON 输出时,随意切换到一个不具备结构化输出能力的模型。

七、AI 服务中的队列分层设计

AI 服务的任务类型差异很大,通常不应该把所有任务放进同一个队列。

7.1 为什么需要多队列

假设系统有三种任务:

  • 实时对话:要求低延迟。
  • 文档解析:执行时间较长。
  • 批量 Embedding:吞吐量优先。

如果三种任务共用一个 FIFO 队列,可能出现:

  • 大量文档解析任务占据队列。
  • 实时对话任务排在长任务之后。
  • 用户等待时间明显增加。
  • GPU 和 CPU 资源无法按业务目标分配。

这属于队头阻塞(Head-of-Line Blocking)。

更合理的方式是按任务类型和优先级拆分队列。

flowchart TD
    A["任务入口"] --> B["任务分类器"]
    B --> C["实时任务队列"]
    B --> D["普通任务队列"]
    B --> E["批量任务队列"]
    C --> F["实时推理 Worker"]
    D --> G["通用 Worker"]
    E --> H["批处理 Worker"]
    F --> I["GPU 推理资源池"]
    G --> J["共享计算资源池"]
    H --> I
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

7.2 按优先级调度

常见优先级:

优先级 任务类型 调度策略
P0 系统关键任务 优先执行
P1 实时交互请求 低排队延迟
P2 普通用户任务 正常调度
P3 批量处理任务 利用空闲资源
P4 离线分析任务 低峰期执行

但是,简单的严格优先级调度会导致低优先级任务长期得不到执行。

这称为饥饿问题(Starvation)。

解决方案包括:

  • 优先级老化:等待时间越长,优先级逐渐提高。
  • 配额调度:为每类任务预留处理能力。
  • 加权公平队列:按照权重分配执行机会。
  • 时间片轮转:不同任务队列轮流获得资源。
  • 最大等待时间:超过阈值后提升优先级。

7.3 资源池隔离

多队列不一定意味着物理资源完全隔离,但关键任务应该有明确的资源保障。

例如:

  • 实时推理使用独立 GPU 资源池。
  • 离线批处理使用剩余 GPU 资源。
  • 文档解析使用独立 CPU Worker。
  • Embedding 使用专门的批处理服务。
  • Agent 工具调用使用独立并发配额。

这样可以降低长任务对实时任务的干扰。

八、异步任务的可靠性设计

队列能够提高系统弹性,但并不自动保证任务只执行一次,也不保证任务永远不会丢失。

可靠性需要从消息投递、任务执行、结果持久化和恢复机制多个层面设计。

8.1 至少一次投递 At-Least-Once

至少一次投递意味着消息可能被重复投递,但只要系统持续恢复,消息最终有机会被处理。

例如:

  1. Worker 获取消息。
  2. Worker 完成模型推理。
  3. Worker 在确认消息前崩溃。
  4. 消息重新进入可消费状态。
  5. 其他 Worker 再次处理。

此时同一任务可能执行两次。

因此,至少一次投递要求业务处理具备幂等性。

8.2 至多一次投递 At-Most-Once

至多一次投递意味着消息最多被交付一次,但可能因为故障而丢失。

如果 Worker 获取消息后立即确认,再执行任务:

  1. Worker 获取消息。
  2. 消息被确认。
  3. Worker 执行过程中崩溃。
  4. 消息不会再次投递。

这种模式可能造成任务丢失。

8.3 恰好一次 Exactly-Once

Exactly-Once 是一个容易被误解的概念。

某些消息系统可以提供特定范围内的事务性或恰好一次处理语义,但这不等于外部模型推理、数据库写入、文件存储和工具调用等所有副作用都天然只执行一次。

例如:

  • 模型已经完成一次付费推理。
  • Worker 在保存结果前崩溃。
  • 消息重新投递。
  • 模型再次执行。

即使消息系统具有事务机制,也不一定能够回滚第一次外部模型调用。

因此,工程实践中通常采用:

至少一次投递 + 业务幂等 + 状态持久化 + 去重机制。

8.4 幂等性设计

幂等意味着相同请求重复执行,不会产生重复业务结果。

常见方法:

唯一任务 ID

为每个业务任务生成唯一 ID。

幂等键

根据业务参数生成稳定的幂等标识。

例如:

document_summary:doc_001:version_3

数据库唯一约束

对幂等键建立唯一索引,防止重复创建结果记录。

状态检查

Worker 执行前先检查任务状态,如果任务已经成功,则不再重复处理。

结果覆盖保护

使用版本号或条件更新,防止旧任务覆盖新结果。

需要注意,幂等不能只依赖 Worker 内存中的集合。因为 Worker 重启后,内存状态会丢失,去重信息必须持久化。

8.5 消息确认机制

消息确认(ACK)决定消息是否可以从待处理状态转为已完成状态。

常见策略:

  • 自动确认:消息投递后自动确认,简单但任务丢失风险较高。
  • 手动确认:任务处理成功后确认,适合可靠任务。
  • 失败拒绝:处理失败时拒绝消息。
  • 重新入队:临时错误时重新排队。
  • 死信转移:无法继续处理时转入死信队列。

对于耗时较长的 AI 任务,通常需要合理配置消息可见性超时、消费确认超时或消息租约。

如果任务执行时间可能超过消息租约,需要定期续租,避免任务仍在执行时被其他 Worker 再次获取。

8.6 事务消息与 Outbox Pattern

异步系统中有一个典型问题:

业务数据库写入成功,但消息发送失败。

例如:

  1. 创建任务记录。
  2. 数据库事务提交成功。
  3. 服务发送消息到队列。
  4. 消息队列暂时不可用。
  5. 数据库中有任务,但队列中没有消息。

这会造成任务永远无法执行。

另一种情况是消息发送成功,但数据库事务回滚,消费者拿到不存在的任务。

Outbox Pattern 可以解决这类双写一致性问题。

核心思路:

  • 在同一个数据库事务中写入业务任务记录。
  • 同时写入 Outbox 事件表。
  • 独立的发布器扫描 Outbox。
  • 将事件发送到消息队列。
  • 发送成功后标记 Outbox 事件已发布。
  • 如果发布失败,后续继续重试。
flowchart TD
    A["接收任务请求"] --> B["开启数据库事务"]
    B --> C["写入任务记录"]
    C --> D["写入 Outbox 事件"]
    D --> E["提交数据库事务"]
    E --> F["Outbox 发布器扫描事件"]
    F --> G["发送消息到队列"]
    G --> H{"发送成功"}
    H -->|"是"| I["标记事件已发布"]
    H -->|"否"| J["保留事件并重试"]
    J --> F
    I --> K["Worker 消费任务"]
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#EAE8FA,stroke:#A49BD5,color:#51477D

Outbox 解决的是数据库与消息队列之间的可靠发布问题,但仍需要处理重复发布,因此消费者仍然需要幂等。

九、重试、退避与死信队列

AI 服务中失败是常态,需要把失败分为不同类型,而不是遇到任何异常都立即重试。

9.1 错误分类

错误类型 是否建议重试 处理方式
网络超时 通常可以 延迟重试
模型服务暂时不可用 可以 指数退避
HTTP 429 可以 遵循 Retry-After
HTTP 500、503 通常可以 限制重试次数
参数校验失败 不可以 直接失败
文件格式不支持 不可以 返回业务错误
权限不足 不可以 终止任务
Token 超出模型限制 不应原样重试 截断或重新处理
GPU OOM 视情况而定 降低并发或切换资源
任务超时 视任务语义而定 检查执行状态后决定

9.2 指数退避 Exponential Backoff