# 客户十分钟发来 5 万个订单，系统怎么扛

> 队列不会让处理变快，但有了竞争消费者和背压，处理节奏由你自己决定。

原文: https://fdetimes.net/zh/guides/queues-competing-consumers-back-pressure/

设想这样一个场景：客户的 ERP 系统跑日终同步任务，十分钟内向你的 webhook 推送了 50,000 个订单。每个订单都要调用一次模型、写一次数据库，再把结果推送到 CRM。你的 API 开始超时，客户那边自动重试，第二天早上你只能去清理被写了两遍的订单。

凡是对接客户系统的人，都应该提前为这种情况做准备。客户的系统不归你管，你也没法让对方“发慢一点”。你能控制的是自己的系统如何接收工作，而这项能力建立在三个概念之上：pub/sub、竞争消费者和背压。

## 队列不会让你更快，而是让你自己选择速度

上面例子的问题在于，webhook 既负责接收，又负责处理。解决办法是把两者拆开：webhook 只把消息写入队列，立即返回 200；一组 worker 从队列中取消息，按自己的节奏处理。

Microsoft 的架构文档描述的正是这个角色：队列是发送方与处理实例之间的缓冲区，在流量涨落时把它削平。

**要点:** 队列不会让系统变快，它给你的是自己决定处理速度的权利。

多个 worker 从同一个队列读取消息，就是竞争消费者模式：worker 之间相互竞争，每条消息只交给其中一个。pub/sub 正好相反：每个订阅者都会收到每条消息。两者的核心区别在于每条消息由谁接收，这决定了你如何设计拓扑。

实际项目中通常两者都要用。一个“新订单”事件只发布一次，“风险评分”订阅者和“CRM 同步”订阅者各自拿到一份副本，每个订阅者内部再挂一组竞争 worker。还有一个附带好处：某个订阅者出故障，不会拖垮发布方或其他订阅者，broker 会替它保存消息，直到它恢复。

## 背压放在哪里？

队列能吸收突发流量，但如果 worker 一次贪心地拉取太多消息，压力只是从 webhook 转移到了 worker 的内存。

Microsoft 的 pub/sub 指南给出了明确的优先顺序：先用 broker 的流量控制限制每个订阅者的未确认消息数，流量控制不够时，再用竞争消费者横向扩展。

每种 broker 把这个控制放在不同的位置，名字也不一样：

| Broker | 在哪里调背压 | 需要记住的点 |
|---|---|---|
| RabbitMQ | prefetch（`basic.qos`） | 值为 0 表示不限制未确认消息数 |
| Celery | `worker_prefetch_multiplier` | 长任务应设为 1，避免 worker 囤积任务 |
| Amazon SQS | 可见性超时（visibility timeout） | 默认 30 秒；标准队列的在途消息上限约为 120,000 条 |
| Kafka | 拉取模型 + 消费者组 | 提前规划分区数：一个分区在组内只属于一个消费者，所以分区数就是并行度的上限 |

Kafka 值得单独说一句。由于消费者自己拉取数据，Kafka 的设计文档指出，慢消费者只是落后一些，有余力时再追上来，背压几乎是白送的。代价是：如果一个 topic 有 6 个分区，同一组里的第 7 个消费者只能闲着，所以设计 topic 时就要算好需要的并行度。

## 完整示例：从头算一遍

回到这 50,000 个订单。假设每个订单平均耗时 2 秒，模型响应慢时最长 45 秒。总工作量是 100,000 worker·秒；用 20 个 worker，队列大约 5,000 秒处理完，也就是 83 分钟多一点。先问客户第一个问题：结果是否必须在 83 分钟内完成？如果是，你马上就知道需要多少个 worker。

接下来是陷阱。如果用 SQS 且保留默认的 30 秒可见性超时，任何耗时 45 秒的订单都会在 worker 删除它之前重新出现在队列里，被另一个 worker 取走。

这个机制本意是从崩溃的 worker 手里抢救任务，在这里却制造了重复。超时时间要设得比你实际测得的最慢处理时间更长。

即便超时设对了，AWS 也明确说明 SQS 是至少一次投递，无法绝对保证消息不会到达两次。Microsoft 也指出，消费者收到消息的顺序并不反映消息的创建顺序。因此消费者必须幂等：

```python
def handle(msg):
    key = f"{msg['order_id']}:{msg['version']}"
    with db.transaction():
        if db.exists("processed_keys", key):
            return  # 重复消息，跳过
        if db.current_version(msg["order_id"]) > msg["version"]:
            return  # 旧版本迟到，跳过
        upsert_order(msg)
        db.insert("processed_keys", key)
```

（两处注释分别表示“重复消息，跳过”和“旧副本迟到，跳过”。）

这两个条件解决的是两个不同的问题。幂等键挡住重复消息；`version` 比较挡住比新消息晚到的旧消息。如果客户系统不发送版本号，就在需求调研阶段问清楚哪个字段单调递增，比如 `updated_at`。

最后一步是毒消息：数据损坏的订单会永远处理失败。不要让它无限循环；投递达到一定次数后，把它移入死信队列（DLQ），留待人工排查。worker 池可以按队列深度自动扩缩容，队列为空时缩到零，同时设置并发上限，以免压垮后面的数据库。

## 按什么顺序做？

第一步是测量：客户的峰值流量、平均和最坏情况下的处理时间，以及业务截止时间。然后用队列把接收和处理分开，判断哪里需要 pub/sub（多个系统关心同一事件），哪里只用竞争消费者就够了。

接着调好控制参数：较小的 prefetch、高于 p99 的可见性超时，以及按目标并行度提前算好的分区数。最后编写幂等消费者，配置 DLQ，并为队列深度和在途消息数设置告警。

## 最常见的错误

最常见的错误是把 prefetch 留在 0，以为“拉得越多越快”，结果一个 worker 囤了几千条消息，其他 worker 却闲着。其次是长耗时的模型调用仍沿用默认的可见性超时。再就是 Kafka 消费者数超过分区数，然后奇怪吞吐量为什么没涨。

剩下两个更危险，因为它们不声不响：假设消息按顺序到达，以及没有 DLQ，导致一条坏记录堵住整个队列。

5 万订单示例里的这条决策链，正是前线部署工程师（FDE）面试时该拿出来讲的内容：峰值流量、worker 数的计算、超时为什么必须大于最慢处理时间、幂等键，以及 DLQ 放在哪里。用你自己的真实数字完整走一遍，比简历上一句“熟悉事件驱动系统”有说服力得多。

下次客户问“你们的系统每秒能处理多少请求？”，最好的回答不是一个数字，而是：对方发多少，系统都能接得住，并且严格按自己能承受的节奏处理。

**本周动手试试:**

- 打开当前项目的 worker 配置，找到 prefetch 或可见性超时的值，和实测的 p99 处理时间对比一下
- 写一个从 RabbitMQ 或 SQS 读取消息的小消费者，故意把同一条消息发两次，证明最终数据依然正确
- 在简历里加一条“应对突发流量”的经历：说明用的队列、worker 数量、如何防止重复，以及跟踪了哪些指标

## 信源

- [Competing Consumers Pattern - Azure Architecture Center | Microsoft Learn](https://learn.microsoft.com/en-us/azure/architecture/patterns/competing-consumers)

- [Publisher-Subscriber Pattern - Azure Architecture Center | Microsoft Learn](https://learn.microsoft.com/en-us/azure/architecture/patterns/publisher-subscriber)

- [Amazon SQS visibility timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)

- [Consumer Prefetch - RabbitMQ](https://www.rabbitmq.com/docs/consumer-prefetch)

- [Apache Kafka Design](https://kafka.apache.org/43/design/design/)

- [Optimizing — Celery documentation](https://docs.celeryq.dev/en/stable/userguide/optimizing.html)
