一个做订单同步的服务选了 RabbitMQ,平时每秒三百条消息,跑得很稳。大促当天生产速率涨到两千条每秒,队列长度在半小时内从零涨到几百万,随后 broker 所在机器的磁盘被写满,整个集群拒绝写入。值班的人第一反应是加消费者,从四台加到十六台,积压不降反升,因为单队列的吞吐已经顶到节点上限,多加的消费者只是多抢同一份消息。

事后看,这不是 RabbitMQ 的错,而是选型时只问了「能不能发消息」,没问「积压时能不能横向扩」。Kafka、RabbitMQ、RocketMQ 都能完成最基本的收发,但它们对「消息怎么存、消费者怎么扩、顺序怎么保」的假设完全不同。选型不是选功能表,是选一套失败模型。

这篇先摆出现象,再讲三者的设计差异,最后用一个可复现的积压模型说明:同样四个消费者,为什么有的能扩、有的不能。本机只装了 Kafka 4.1.2(KRaft 模式,broker 9094),RabbitMQ 与 RocketMQ 没有安装;Kafka 命令是实跑,另外两家标注「未在本机实测」;积压数字来自本机 Node 仿真。

先认出现象:选错的代价

消息队列的问题很少在「发不出去」,多数在「堆起来之后」。下面这些现象,选型阶段就能预判。

现象真实原因第一步查什么
加消费者后积压不降分区数少于消费者数,多出来的实例分不到分区对比主题分区数与活跃消费者数
单队列吞吐顶住,延迟一直涨队列型中间件受单节点吞吐上限约束,横向扩依赖拆队列看单节点 CPU、磁盘写入与队列数量
消息延迟从毫秒变成分钟消费端在批量拉取或长轮询,积压时批间等待被放大看消费者的拉取批量、等待参数与实际处理耗时
磁盘使用率持续上升直到写满没有设置保留时长或容量上限,积压消息无限增长看主题的保留策略与磁盘余量
同一订单的消息顺序错乱分区键选错,同一实体被分到多个分区并行消费查分区键是否按业务实体,消费者是否单线程处理分区
重试消息把正常消息挤到后面失败消息立即重回队首或同一队列,形成重试风暴看重试策略、延迟级别与死信队列
运维每天在处理集群故障组件数量与团队能力不匹配,选了需要专人维护的架构算每月用于运维的人时与故障次数
事务消息与普通消息混在一个主题关键消息被非关键消息的积压和重试拖累看主题拆分与各自的消费组

三者不是同一类东西

先用一句话概括差异:Kafka 像一个可追加、可重复读的分布式日志;RabbitMQ 像一套灵活的路由与投递系统;RocketMQ 介于两者之间,强调事务消息和顺序消息,面向业务场景做了更多封装。

日志型(Kafka)

消息按分区追加写盘,消费完不删除,靠保留时长或容量清理。消费者自己记位点,可以重复读、可以回放。吞吐高,适合流式数据和事件溯源;单条延迟不占优势,且依赖分区数扩容。

队列型(RabbitMQ)

消息被消费后从队列移除,靠交换机与绑定做灵活路由,支持延迟队列、优先级。单条延迟低,适合任务分发;吞吐受单队列与单节点限制,积压时横向扩比较麻烦。

RocketMQ 的定位更接近「业务消息总线」:支持事务消息、定时消息、顺序消息,队列模型类似 Kafka 但做了更多运维与业务封装。它在国内电商、金融场景用得多,原因是这些场景对「消息不丢、事务一致、顺序可保」的要求更明确。

所以第一个选型问题不是「哪个性能高」,而是「你的消息是事件还是任务」。事件是「发生过的事」,可能被多个下游重复读,适合日志型;任务是「请做一件事」,做完就该消失,适合队列型。这个分类决定了后面所有参数。

Kafka 的假设:分区、顺序、可回放

Kafka 把主题切成若干分区,每个分区是一个有序日志。生产者按分区键决定消息去哪个分区,消费者组内每个分区只能被一个消费者处理。这个设计带来两个直接结果:分区内严格有序;消费者数量超过分区数后,多出来的实例空闲。

本机模型里,主题六个分区、八个消费者,有两个消费者分不到分区,全程空闲。这不是配置错误,是模型限制。要扩到八个消费者都干活,分区数至少要八个,而且分区数只能在创建时定,后期扩分区会打乱原有键的路由,影响顺序。真跑时建了三个分区的 demo-orders,消费者组 g2 起两个实例,实际分到两个分区和一个分区,第三个实例再加就会空闲。

Kafka 适合:日志采集、行为埋点、变更数据捕获、需要回放或重新消费的场景、吞吐远大于延迟要求的场景。它不适合:需要按消息做复杂路由、需要单条低延迟、消息量很小却要维护一套集群、需要「消费即删除」的临时任务。

「可回放」是它最容易被低估的能力。消费者上线新逻辑后,可以从头或从某个时间点重新读,不用生产者重发。这对修数据、补历史很有用。代价是保留期内的数据都占磁盘,保留七天和保留三十天,磁盘需求差四倍。选保留策略时,要先问「最坏情况下要回溯多久」,而不是照抄别人的配置。

它的运维成本不低:要管 broker、分区分布、副本同步、磁盘容量、消费者位点。集群规模小的时候,这些成本摊到每條消息上会非常贵。

RabbitMQ 的假设:路由灵活、消费即走

RabbitMQ 的核心是交换机与队列的绑定。生产者把消息发给交换机,交换机按规则投到一个或多个队列,消费者从队列取。它擅长「一条消息按不同规则分发给不同下游」,也支持延迟队列、优先级队列、死信队列。

它的扩容逻辑不同:加消费者能提高单队列的消费速度,但所有消费者抢的是同一个队列,吞吐最终受 broker 单节点和队列本身限制。要横向扩,通常要拆成多个队列,再让消费者分别消费,这会牺牲「全局顺序」并增加路由复杂度。

RabbitMQ 适合:任务分发、异步通知、需要复杂路由和延迟投递的业务、消息量中等且延迟敏感的场景。它不适合:海量事件流、需要长期保留和回放、需要靠加机器线性扩吞吐的场景。

本机模型里,单队列八个消费者可以全部工作,这是它的优势;但模型也注明「单队列吞吐受单节点上限约束」。换句话说,它能把现有机器用满,但不一定能靠加机器继续扩。

还有一个参数会直接影响积压时的表现:预取数量。每个消费者一次拉多少条消息在本地缓冲,设得大,吞吐高但故障时未处理的消息要等超时才重回队列;设得小,公平但频繁往返。积压时把预取调大能短期提速,代价是消费者重启后恢复更慢。这个参数没有标准值,要按单条处理耗时和可容忍的重投量来调。

RocketMQ 的假设:业务消息与一致性

RocketMQ 的队列模型和 Kafka 类似,按队列分区、按分区保序,但它在业务侧多做了几件事:事务消息(先发半消息,等本地事务结果再提交)、定时与延迟消息、顺序消息、消息轨迹。这些能力对电商下单、库存扣减、支付回调这类场景很实用。

它的代价是生态和运维。相比 Kafka,它的社区规模小一些,跨语言客户端和周边工具没那么丰富;集群部署需要 NameServer、Broker、Proxy 等组件,规模小时显得重。选它通常是因为业务确实需要事务消息或顺序消息,而不是因为它「性能最好」。

适合:订单、支付、库存等需要事务与顺序的业务消息;需要消息轨迹排查的场景;国内团队、已有运维经验的环境。不适合:纯日志采集、超大规模流式处理、团队完全没有相关经验且消息量很小。

事务消息也不是免费的。它要求生产者能处理「半消息发送成功、本地事务结果未知」的中间态,还要提供一个回查接口给 broker 调用。这个接口必须幂等、能快速返回,否则消息会长期挂在「待确认」。用了事务消息却把回查写得含糊,最后会出现一部分消息永远不提交也不回滚。

用积压模型做选型

选型时最该算的一个数,是「生产速率减去消费能力」。消费能力等于消费者数量乘以单条处理耗时的倒数。这个公式和中间件品牌无关,但不同中间件能加的消费者上限不同。

本机模型设定生产每秒三百条、单条处理三十毫秒。两个消费者时,消费能力 66.7 条每秒,净增 233.3 条每秒,一小时积压 84 万条;四个消费者 133.3 条每秒,净增 166.7,一小时 60 万;六个 200 条每秒,净增 100,一小时 36 万;八个 266.7 条每秒,净增 33.3,一小时 12 万;十二个 400 条每秒,净增负 100,不再积压。

生产 300/s,单条 30ms:
2 消费者  能力 66.7/s   净增 233.3/s   1h 积压 84 万
4 消费者  能力 133.3/s  净增 166.7/s   1h 积压 60 万
6 消费者  能力 200.0/s  净增 100.0/s   1h 积压 36 万
8 消费者  能力 266.7/s  净增 33.3/s    1h 积压 12 万
12 消费者 能力 400.0/s  净增 -100.0/s  不积压

把积压换算成资源:六十万条、每条 1KB,约 586MB;三副本就是 1.72GB。生产者停止后,四个消费者排空需要 75 分钟。这个数决定了「磁盘要留多少余量」和「事故恢复要多久」。

选型结论就藏在这两个数里:如果业务可能长期积压,需要靠加消费者线性扩,那么分区数可调、消费者可并行的日志型更合适;如果消息量稳定、要求低延迟和复杂路由,队列型更合适;如果还需要事务和顺序,再考虑 RocketMQ。先用模型算出「需要多少个消费者」,再看候选中间件能不能支持这么多消费者,比看 Benchmark 数字靠谱。

模型里的「三十毫秒」是平均值,真实处理耗时是分布的。如果百分之一的长尾要三秒,积压会被这些慢消息拖住;消费者看起来都在忙,吞吐却上不去。所以容量规划要用接近峰值的分位数,比如九十五分位,而不是平均。平均值只适合做粗算,不能用来决定「加不加机器」。

关键配置样例

下面三段配置分别对应三种中间件的关键参数。Kafka 那段在本机实际建过主题,另外两段按官方语义书写。

# Kafka:分区数决定消费者上限,保留策略决定磁盘(本机实测,分区数用 3)
kafka-topics.sh --create --topic order-events \
  --partitions 12 --replication-factor 3 \
  --config retention.ms=604800000 \
  --config retention.bytes=10737418240

# RabbitMQ:单队列靠消费者并发,延迟与死信用参数声明(未实测)
rabbitmqctl add_vhost /prod
rabbitmqctl set_policy ha-all "^order\." \
  '{"ha-mode":"all","ha-sync-mode":"automatic"}' --vhost /prod

# RocketMQ:顺序消息按业务键选队列,事务消息用半消息(未实测)
# 生产者发送顺序消息时指定 MessageQueueSelector,按订单号取模选队列
# 事务消息先 sendMessageInTransaction,本地事务结果回查后再 commit

Kafka 的分区数要在创建时想清楚。十二个分区至少能带十二个消费者,留出两倍余量意味着按峰值吞吐规划,而不是按平时。副本数三意味着磁盘要按三倍算,前面那 1.72GB 就是这么来的。

RabbitMQ 的镜像队列能提高可用性,但会放大写入开销:每条消息要同步到多个节点。消息量大时,镜像队列可能成为瓶颈。生产上常见做法是关键队列镜像、普通队列单副本,而不是一刀切。

RocketMQ 的顺序消息要求同一业务键进同一队列,同时消费者要单线程处理该队列。分区键选错,顺序保证就没了;消费者开多线程处理同一队列,顺序也会乱。这两个约束要在代码里显式体现,不能只靠配置。

不要用「消息量小所以随便选」来做决定。消息量小的时候,任何中间件都能跑;真正的差别在故障和积压时。选型要看最坏情况,而不是平均值。

怎么验证:命令与成功判据

下面命令用于验证「消费者是否真的并行、积压是否真的在降」。Kafka 部分在本机实跑,输出照录;RabbitMQ 与 RocketMQ 未安装,命令仅作对照。

# Kafka:看主题分区、消费者组积压
kafka-topics.sh --describe --topic order-events
kafka-consumer-groups.sh --describe --group order-sync

# RabbitMQ:看队列深度、消费者数、入出队速率
rabbitmqctl list_queues name messages consumers
rabbitmqctl list_queues name message_stats.publish_details.rate \
  message_stats.deliver_get_details.rate

# RocketMQ:看主题队列分布与消费进度
mqadmin topicStatus -n 127.0.0.1:9876 -t order-events
mqadmin consumerProgress -n 127.0.0.1:9876 -g order-sync
# 本机实际输出(Kafka 4.1.2,KRaft 单节点,broker 9094)
$ kafka-topics.bat --create --topic demo-orders --partitions 3 --replication-factor 1
Created topic demo-orders.

$ kafka-topics.bat --describe --topic demo-orders
Topic: demo-orders  TopicId: ZRy2TltJSbmVyJ3jqf3b4w  PartitionCount: 3  ReplicationFactor: 1
  Partition: 0  Leader: 1  Replicas: 1  Isr: 1
  Partition: 1  Leader: 1  Replicas: 1  Isr: 1
  Partition: 2  Leader: 1  Replicas: 1  Isr: 1

$ kafka-consumer-groups.bat --describe --group g1
GROUP  TOPIC        PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
g1     demo-orders  0          5               3838            3833
g1     demo-orders  1          0               0               0
g1     demo-orders  2          0               1172            1172
# 合计积压 5005 条;停掉消费者后灌入 5000 条

$ kafka-consumer-groups.bat --describe --group g2
# 两个消费者在线:成员 A 分到分区 0、1,成员 B 分到分区 2
# 消费到 LOG-END-OFFSET 后,各分区 LAG 均为 0

成功判据:消费者组里每个实例都有分区或队列可消费,没有长期空闲实例;积压数在流量平稳时持续下降,而不是维持高位;入队速率与出队速率的差值可以解释积压变化;磁盘使用率在保留策略范围内波动,不持续单向增长。

还要验证扩容行为:把消费者从四个加到八个,观察实际吞吐是否接近翻倍。如果没翻倍,先看分区数或单节点瓶颈,而不是继续加机器。这个演练能直接暴露选型是否匹配。

另外要检查分区倾斜。分区键选得不好,某个分区会承接大部分消息,其它分区闲着。表现是「总积压不算高,但某个分区的消费延迟特别大」。看每个分区的入队速率和消费速率,比看主题总量更容易发现这类问题。

什么时候不该上,以及边界与代价

请求必须同步返回结果、任务执行时间是毫秒级、下游只有一个、流量稳定且远低于处理能力时,队列带来的复杂度大于收益。这时用进程内异步或后台任务表就够了。

团队没有能力维护集群时,不要选组件最多的方案。一个需要三班倒值守的中间件,会把小团队拖垮;宁可先用简单的队列型,把业务跑起来,等规模真的到了再迁。

队列会引入「最终一致」。生产者发出消息后,消费者可能几秒后才处理,中间这段时间数据是不一致的。业务要能接受,或者要有对账兜底。不能接受最终一致的场景,不要用队列做「伪同步」。

成本上,队列的存储、网络、运维都要算进去。三副本意味着三倍磁盘,跨可用区意味着跨区流量费,积压意味着要预留容量。这些成本在选型时经常被忽略,最后变成账单上的意外。

三种中间件可以在一个系统里共存,但每多一种,就多一套监控、升级、告警和值班知识。小团队最常见的错误是「日志用 Kafka、任务用 RabbitMQ、订单用 RocketMQ」,结果三种都只懂一半。能统一就统一,实在要分开,也要把边界写清楚,比如「事件流走 Kafka,业务命令走 RocketMQ」。

当天能自验的五个练习

一,用 Node 写一个生产者与消费者的仿真:固定生产速率,改变消费者数量,记录每小时积压量。成功判据:结果能复现上面那张表的数量级,且能解释「为什么消费者数量到某个值后不再有用」。

二,给模型加上「分区数上限」:消费者最多只能等于分区数,观察加机器后的实际吞吐。成功判据:能说出「分区数成了瓶颈」和「单节点成了瓶颈」两种情况的区别。

三,把单条处理耗时从三十毫秒改成十毫秒,重跑模型,观察达到不积压所需的消费者数量。成功判据:能算出「优化处理耗时」和「加消费者」哪个更划算。

四,算一次磁盘账:给定积压条数、单条大小、副本数、保留天数,算出需要的磁盘容量。成功判据:结果与本文的 586MB、1.72GB 同一量级,并能说明保留策略如何影响容量。

五,读一遍三种中间件的官方「限制」章节,各写下三条「它明确不擅长的事」。成功判据:能不看资料说出每种中间件的一条硬限制,而不是只记得吞吐数字。

和下一篇的关系

队列解决「异步与削峰」,搜索解决「按条件快速找」。下一篇讲 Elasticsearch:它为什么不能当主库、写入到可见为什么有延迟、深分页为什么会拖垮集群,以及双写缺口怎么补。搜索中间件最容易犯的错,是把它当成数据库用。

选型这件事没有标准答案,只有「和你的失败模型匹配不匹配」。先把积压、顺序、延迟、运维四笔账算清楚,再去看功能表。