一个电商系统在促销日引入消息队列,思路很标准:下单成功后发一条消息,异步做发券、积分、短信。上线当天队列积压到八百万条,第二天中午才消化完;更糟的是有用户收到三张一样的券,客服电话被打爆。开发第一反应是「MQ 不可靠」,换了另一套消息中间件,问题原样复现。

根因有两层。第一层是消费能力算错了:生产者每秒 300 条,消费者单条处理 30 毫秒,四个消费者理论处理 133 条每秒,从第一分钟起就在净积压。第二层是「至少一次投递」被当成了「只投一次」:消费者处理完业务、还没提交确认就重启,消息被重新投递,发券逻辑没有去重,于是同一张券发了三次。

队列不是「把同步改成异步」的开关,它是一套新的失败模型。用之前要先回答:这条消息能不能重复、能不能丢、要不要顺序、积压到什么程度算事故。这篇按这四个问题展开。

先认出现象

队列的问题大多不在队列本身,而在生产者和消费者之间的约定。下面这些现象经常一起出现。

现象真实原因第一步查什么
队列积压持续增长,几小时不降消费速率低于生产速率,或消费者卡在某个慢依赖上算「生产条数每秒」与「消费条数每秒」,看消费者处理耗时分布
用户收到重复短信或重复券至少一次投递加上消费者重启,业务没有幂等看消息 ID 是否唯一、消费记录表是否有唯一键
同一订单的状态先变成已支付又变回待支付消息乱序,或同一订单被多个分区并行处理查分区键是否按订单号,消费者是否单线程处理该分区
消息发出去了,但业务没执行生产者先提交事务再发消息,发消息失败没有补偿查是否有本地消息表或事务消息,失败消息去哪了
重启消费者后,一批消息同时涌入积压期间消费者不在线,恢复后全量拉取,没有限速看消费者的拉取批量与并发配置
死信队列越堆越多,没人看失败消息进入死信后没有告警和处理流程查死信队列的监控与责任人
扩容消费者后,积压反而更慢下游数据库连接被打满,或分区数少于消费者数看数据库连接数、分区数与消费者实例数

这里面最容易被忽略的是第三条和第四条:一个管「顺序」,一个管「不丢」。很多团队只监控队列长度,不监控重复率和死信量,等于只看体温不看伤口。

什么时候真的需要队列

队列的价值可以归成三类,每一类都有替代方案,不是非上不可。

削峰瞬时流量远高于后端处理能力,比如秒杀、整点推送。队列把瞬时洪峰摊平到一段时间。替代方案是限流加排队页,让用户知道在等,成本更低。
异步主流程不需要等结果,比如发短信、生成报表、转码。替代方案是进程内线程池或后台任务表,量小的时候够用,量大了才需要独立队列。
解耦一个事件要触发多个下游,且下游经常增删。队列让生产者和消费者互不依赖。替代方案是同步调用加超时,但下游一多,主流程会被最慢的那个拖住。

什么时候不需要队列?请求必须立即返回结果、任务执行时间很短、只有一个消费者、流量稳定且远低于处理能力。这些场景引入队列,只会多一套要运维的组件和一套最终一致的复杂度。

一个判断标准:如果去掉队列,业务逻辑仍然正确,只是慢一点,那队列是优化;如果去掉队列业务就不成立,那队列是架构的一部分,必须按核心链路对待,配监控、告警、演练和容量规划。

还要评估「消息丢了会怎样」。发券消息丢了,用户少一张券,可以补发;支付成功消息丢了,订单永远不到账,必须靠对账兜底。不同重要级别应该走不同的主题、不同的重试策略,甚至不同的中间件。把所有消息塞进一个主题,关键消息会被普通消息的积压拖住,也会被普通消息的重试策略连累。

最常见的过度设计是「为了以后可能的高并发先上 Kafka」。系统当前每秒不到十单,却要维护分区、副本、消费组和监控。等流量真的上来再换,迁移成本远低于长期养一套用不上的基础设施。

投递语义:没有真正的「只消费一次」

消息中间件通常提供三种语义。最多一次:消息可能丢,但不会重复;至少一次:消息不会丢,但可能重复;精确一次:理论上不丢不重,但代价高,而且只在特定条件下成立。

绝大多数业务用的是至少一次。因为「不丢」比「不重」更重要:丢一条支付成功消息,订单永远到不了账;重复一条,最多多发一张券。所以真正要做的不是追求精确一次,而是让消费逻辑幂等,重复执行结果不变。

幂等的实现方式有三种。第一种是业务状态机:订单只能从「待支付」变成「已支付」,重复消息到来时状态已经是「已支付」,直接跳过。第二种是去重表:用消息 ID 或业务唯一键建唯一索引,插入成功才处理,冲突就丢弃。第三种是原子占位:处理前先用 SET NX 或数据库唯一键占位,处理成功再标记完成。

第二种和第三种看起来像,差别在并发。下面是我在本机用 Node 跑的一个对照:500 次投递,实际上只有 100 个不同订单,模拟「先查后写」和「原子占位」两种消费逻辑。

先查后写(非原子): { total: 500, charged: 500, deduped: 0 }
原子占位(SET NX): { total: 500, charged: 100, deduped: 400 }

「先查后写」在并发下全军覆没:两个消费者同时查到「没处理过」,然后都写入了。原子占位只放行了 100 次,其余 400 次在占位阶段就被挡住。这不是语言或库的问题,是「检查」和「写入」之间必须原子。数据库唯一索引、Redis 的 SET NX、条件更新 UPDATE ... WHERE status='pending',都是在做这件事。

去重键要选对。用消息中间件给的 message id 只能防同一条消息重复投递,防不住「业务重复提交」;用业务键(订单号 + 动作)能防业务重复,但如果同一订单要发多次不同通知,就会误杀。通常两者结合:消息 ID 做传输层去重,业务键做业务层去重。

去重记录也要能清理。如果永远保留,表会越来越大,查询越来越慢;如果清理太早,晚到的重复消息又会被重新执行。保留时间应该覆盖「消息可能延迟的最大时间」,通常七天到三十天,再配合业务唯一键做永久兜底。清理任务本身也要幂等,不能因为删记录把正在处理的消息误判成未处理。

顺序:只能按分区保证

队列的「顺序」不是全局顺序,而是分区内顺序。同一个分区同一时刻只有一个消费者在处理,所以分区内的消息按进入顺序执行;跨分区没有顺序保证。

因此要保序,必须把需要保序的消息路由到同一个分区。订单相关消息用订单号做分区键,同一订单的创建、支付、发货事件都会落到同一分区;用户相关消息用用户 ID。分区键选错,比如用随机数或时间戳,顺序保证就没了。

分区键还会影响负载均衡。分区键太集中,某个分区会成为热点;分区键太散,又保不住顺序。用一致性哈希可以在扩分区时减少消息搬家。下面是我在本机跑的分片结果:十万条消息、八个队列、每个队列 150 个虚拟节点,然后扩到九个队列。

8 个队列的分片占比(%): {
  q5: 12.24, q6: 12.16, q2: 12.5, q4: 13.56,
  q7: 14, q1: 11, q8: 11.98, q3: 12.56
}
最小/最大占比(%): 11.00 14.00
扩到 9 个队列:一致性哈希搬家 10845 (10.85%)
扩到 9 个队列:取模哈希搬家 88951 (88.95%)

八个队列的目标占比是 12.5%,实际落在 11% 到 14% 之间,这是虚拟节点数量有限带来的偏差。扩到九个队列时,一致性哈希只让约 10.85% 的消息换队列,接近理论值 11.1%;取模哈希则搬了 88.95%,几乎全部重排。对需要保序的系统,大面积搬家意味着大量消息在错误的分区里被消费,顺序直接乱掉。

还要注意重平衡。消费者实例增减、某个消费者心跳超时,都会触发分区重新分配。重平衡期间,原来的消费者可能已经处理完业务但还没提交位点,新消费者从旧位点开始,同一个消息会被处理两次。这不是队列的 bug,是至少一次语义的必然结果,只能靠幂等兜住。

业务上的「顺序」也要定义清楚。是同一订单的事件必须按创建、支付、发货的顺序处理,还是只要最终状态正确?前者需要严格分区和串行消费,后者可以并发处理,只要状态机允许乱序到达时回退或忽略。很多团队不假思索地要求「全局有序」,结果把吞吐压得很低;把顺序范围缩小到「同一实体」,往往就能既保正确又保性能。

积压:先算,再动手

积压不是看队列长度吓自己,要算净增长速率。公式很朴素:消费能力等于消费者数量乘以单条处理耗时的倒数,再乘以并行度。生产速率减去消费能力,就是每秒净积压。

开头那个例子:生产 300 条每秒,四个消费者,单条 30 毫秒,单消费者每秒约 33 条,总算力 133 条每秒,净积压 167 条每秒,一小时约 60 万条,一天约 1440 万条。这个数在引入队列的当天就能算出来,不需要等积压发生。

积压发生后的处理顺序:先确认消费者是否卡住,比如某个下游超时、数据库连接池耗尽;再看分区数是否够,消费者扩到超过分区数没有意义;然后评估能否临时提高并发,注意别把下游打挂;最后才是限流生产者或丢弃非关键消息。

扩容不是万能药。如果瓶颈在数据库写入,消费者从四个加到十个,只会让数据库更慢,积压更严重。正确做法是先找到消费者里最慢的那一步,优化它或给它单独限流,再扩容。

死信队列要有主人。失败消息进入死信不等于处理完,要有告警、有查看入口、有重放入口,还要区分「可重试」和「永远失败」。没有这些,死信队列只是一个好看的垃圾桶。

监控至少要看五个数:积压条数、积压增速、消费速率、重复消费比例、死信增速。只看积压条数不够,因为积压可能在一个高位稳定着,真正危险的是「消费速率掉到零」或「死信突然暴涨」。告警阈值要按业务能容忍的延迟来定,比如「积压超过十分钟的处理量」才告警,而不是积压到一万条就响,那样只会让人麻木。

一套可落地的骨架

先建两张表:业务表本身带状态,消费记录表带唯一键。去重不靠内存,靠数据库约束。

CREATE TABLE consume_record (
  message_id   VARCHAR(64) PRIMARY KEY,
  topic        VARCHAR(64) NOT NULL,
  consumed_at  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE coupon_grant (
  order_id   BIGINT PRIMARY KEY,
  coupon_id  BIGINT NOT NULL,
  status     VARCHAR(16) NOT NULL DEFAULT 'granted'
);

消费者按「占位、处理、提交」三步走。注意顺序:先占位再处理,处理失败要释放占位或留给重试,不能先把消息确认掉。

async function consume(msg) {
  const id = msg.id;
  const inserted = await db.query(
    "INSERT INTO consume_record(message_id, topic) VALUES ($1, $2) ON CONFLICT DO NOTHING",
    [id, "coupon.grant"]
  );
  if (inserted.rowCount === 0) return ack(msg);   // 已处理过

  await grantCoupon(msg.payload.order_id);        // 业务本身也要幂等
  await ack(msg);
}

生产者这一侧,不要在数据库事务提交前发消息,也不要在提交后「尽力而为」地发。用本地消息表:业务写入和消息记录在同一个事务里,后台任务扫描未发送的记录投递,发送成功再标记。这样至少不会出现「订单成了、消息没了」。

消费者要限速,尤其是在积压恢复或刚重启时。一次拉几千条、开几百个并发,看起来能快速消化积压,实际会把下游数据库打满,处理失败率上升,消息反复重投,积压反而更久。正确做法是按下游能力设并发上限,必要时分批拉取,先保证处理成功,再谈速度。生产者也要能在积压时降级,比如暂停非关键通知,把资源留给支付和订单。

BEGIN;
INSERT INTO orders(id, status) VALUES (1024, 'paid');
INSERT INTO outbox(id, topic, payload, status) VALUES (gen_random_uuid(), 'order.paid', '{...}', 'pending');
COMMIT;

目录结构按职责分,别把生产、消费、重试混在一个文件里。

src/
  messaging/
    producer.js        统一发送入口,带 outbox 扫描
    consumer.js        拉取、占位、处理、确认
    retry-policy.js    重试与死信判定
    topics.js          主题与分区键约定
  jobs/
    coupon-grant.js    具体消费逻辑

验证方法:本地起一个 Redis 或 RabbitMQ,发送一条消息,确认只产生一条业务记录;重复发送同一条,确认业务记录仍只有一条;停掉消费者再发十条,恢复后确认全部处理且没有重复;把分区键改成订单号,确认同一订单的事件按顺序被消费。中间件安装与集群配置未在本机实测。

docker run -d --name mq -p 5672:5672 -p 15672:15672 rabbitmq:3-management
curl -u guest:guest http://localhost:15672/api/queues/%2F/coupon.grant

边界与代价

队列把同步失败变成异步失败。同步调用失败,用户立刻看到错误;异步失败,用户以为成功了,几小时后才发现券没到账。所以异步链路必须有对账和补偿,不能只靠重试。

最终一致会渗透到产品逻辑。下单后立刻查券可能查不到,需要前端提示「稍后到账」,或者做一次短轮询。产品不接受这种延迟,就不该把这条链路异步化。

运维成本是持续的。队列要监控积压、消费速率、重复率、死信量、分区倾斜;要演练消费者宕机、分区重平衡、中间件重启。这些成本不会因为「用了云服务」而消失。

顺序和吞吐是矛盾的。要严格保序,就得接受单分区单消费者,吞吐上不去。缓解办法是拆更多分区,但分区多了,跨分区事务和全局顺序又没法保证。业务通常只需要「同一实体有序」,不需要全局有序,先把这个范围划清。

过度设计的信号:只有一个消费者、每秒几条消息,却上了多副本集群、死信、延迟队列、事务消息全套。先用数据库任务表加定时轮询,能撑很久。

当天可以自验的五件事

  1. 算一遍你系统里队列的生产速率和消费能力,写出净积压是正还是负;如果是正,当天就能预测什么时候出事。
  2. 找一条消费逻辑,问它「同一消息执行两次会怎样」;答案不是「结果一样」的,就要补幂等。
  3. 检查消费记录表或去重键是否有唯一约束;只有应用层 if 判断的,在并发下不算数。
  4. 确认分区键是什么;如果是随机数,找一个需要保序的业务,看看乱序会造成什么。
  5. 给死信队列配一个告警,并写清楚谁来看、怎么重放;没有责任人的死信队列等于没有。

下一篇讲定时任务与幂等。队列解决「事件来了怎么异步处理」,定时任务解决「到点必须做什么」。后者看起来更简单,但重复执行、漏执行、多实例抢任务这三个坑,一个都不少。