消息队列选型别只看吞吐:Kafka、RabbitMQ、RocketMQ 的语义差异与三个必踩的坑
技术选型会上最常见的场景:有人贴出一张 benchmark 图,Kafka 单机百万条每秒,RabbitMQ 几万条,于是结论是"我们要用 Kafka"。半年后发现问题不在吞吐——消息偶发丢失、下游重复扣款、订单状态倒挂,这些都不是吞吐能解释的。
消息队列的选型本质上是选三种语义:投递保证、顺序范围、积压后的行为。吞吐只是入场券,语义才决定你后面要写多少补偿代码。
一、先分清你要的是"队列"还是"日志"
这两个词经常混用,但它们是两种不同的数据结构。
队列(queue):消息被消费后从队列里移除。同一条消息只会被一个消费者处理(或者在广播模式下被每个订阅组各处理一次)。语义接近"任务分发"。
日志(log):消息追加写入分区文件,消费位点(offset)由消费者自己维护。同一条消息可以被多个消费组重复读取,也可以被回放。语义接近"事件流"。
这个区别带来的直接影响是:
| 需求 | 应该选 | 原因 |
|---|---|---|
| 下单后发短信、发邮件 | 队列 | 任务型,处理完就该消失 |
| 订单状态变更,要同步给 5 个下游 | 日志 | 多方订阅,各自维护位点 |
| 需要按时间回放历史事件补数据 | 日志 | offset 可重置,队列不行 |
| 延迟任务、定时重试 | 队列(带延迟级别) | 需要精确的单条调度 |
| 削峰填谷、抗积压 | 两者都行,看积压规模 | 日志型在千万级积压时更稳 |
很多团队用 Kafka 做任务分发,然后发现"想重发一条消息"很麻烦——因为位点一提交,那条消息就再也读不到了,除非重置整个分区的 offset。这不是 Kafka 的缺陷,是用错了模型。
二、三种主流产品的真实差异
不谈参数,只谈行为。
| 维度 | Kafka | RabbitMQ | RocketMQ |
|---|---|---|---|
| 模型 | 分区日志 | AMQP 队列 + 交换机 | 队列(基于 commitlog) |
| 投递语义 | 至少一次(配幂等可近似恰好一次) | 至少一次 | 至少一次,支持事务消息 |
| 顺序性 | 分区内有序 | 单队列单消费者有序 | 队列内有序 |
| 单条延迟 | 毫秒级,批量下会更高 | 微秒到毫秒,最灵活 | 毫秒级 |
| 积压能力 | 强,磁盘顺序写 | 弱,堆积受内存和流控影响 | 强,commitlog 顺序写 |
| 延迟消息 | 不支持(需外部调度) | 支持 TTL + 死信 | 支持 18 个延迟级别 |
| 事务消息 | 支持(0.11+,仅 Kafka 事务) | 不支持(需本地消息表) | 原生支持 |
| 运维复杂度 | 中高(分区、副本、再均衡) | 低 | 中(NameServer 轻量) |
| 典型适用 | 日志采集、事件流、大数据管道 | 业务解耦、RPC 异步化、复杂路由 | 电商交易、订单、金融场景 |
几个容易被忽略的差异点:
RabbitMQ 的交换机是它真正的优势。 direct、topic、fanout、headers 四种路由策略,加上死信队列和 TTL,能组合出很复杂的路由逻辑,不用在应用层写分发代码。Kafka 没有这个概念,所有路由都得消费者自己判断。
RocketMQ 的事务消息解决的是"本地事务和发消息的原子性"。 它先发半消息,本地事务执行成功后再 commit,失败则回滚,broker 还会回查。这套机制在订单创建 + 扣库存的场景里非常实用,Kafka 的事务只保证"多条消息原子写入",不解决本地事务一致性问题。
Kafka 的分区数不是越多越好。 分区多了,再均衡变慢、文件句柄变多、端到端延迟上升。经验值:单个 broker 上的分区总数控制在 2000 以内,单分区吞吐按 10MB/s 估算。
三、坑一:以为"至少一次"就等于不会丢
"至少一次"的准确含义是:不保证不丢,只保证不静默地丢。它允许重复,也允许在某些边界条件下丢。要真的不丢,得把三段的配置都补齐。
生产者侧
Kafka 的默认配置是 acks=1,只等 leader 写入就返回。如果 leader 写完立刻宕机、副本还没同步,这条消息就丢了,而生产者收到的是成功。
# 生产端
acks=all
enable.idempotence=true
max.in.flight.requests.per.connection=5
retries=2147483647
delivery.timeout.ms=120000
acks=all 要配合 broker 侧的 min.insync.replicas 才有意义:
# broker 侧
replication.factor=3
min.insync.replicas=2
unclean.leader.election.enable=false
min.insync.replicas=2 的含义是:至少两个副本确认才算写入成功。如果可用副本不足两个,生产端会直接收到错误,而不是"看起来成功"。unclean.leader.election.enable=false 是防止一个落后很多的副本被选为 leader——那会丢掉它没同步的那些消息。
Broker 侧
刷盘策略决定"操作系统崩溃"时的丢失窗口。RocketMQ 的 flushDiskType=SYNC_FLUSH 表示每条消息同步刷盘才返回,性能下降明显,但能扛住机器掉电。异步刷盘在掉电时会丢掉页缓存里还没落盘的部分。
RabbitMQ 需要同时满足三个条件才算持久化:队列 durable、消息 deliveryMode=2、交换机 durable。少一个,重启后消息就没了。
消费侧
最常见的丢消息其实发生在这里:先提交位点,再处理业务。处理过程中进程被 kill,消息就永久丢了。
// 错误:自动提交,处理失败也提交了
props.put("enable.auto.commit", "true");
// 正确:手动提交,处理成功后再提交
props.put("enable.auto.commit", "false");
while (true) {
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(500));
for (ConsumerRecord<String, String> r : records) {
handle(r); // 业务处理
}
consumer.commitSync(); // 全部处理完再提交
}
这里的取舍是:提交越晚,重复消费的概率越高;提交越早,丢消息的概率越高。业务能接受重复但不能接受丢,就选后者。
四、坑二:消费端没做幂等,重试就是重复扣款
只要用了"至少一次",就必须假设消息会重复。重复的来源有三个:生产者重试、消费者 rebalance 后重新拉取、消费者处理成功但提交位点失败。
三种常见的幂等实现,按可靠性排序:
1. 数据库唯一约束(最可靠)
CREATE TABLE mq_consume_log (
msg_key VARCHAR(64) NOT NULL,
biz_type VARCHAR(32) NOT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (msg_key)
);
-- 消费时先插入,插入失败说明已处理过
INSERT INTO mq_consume_log(msg_key, biz_type) VALUES ('order-12345-paid', 'ORDER_PAID');
配合业务表在同一个本地事务里提交,就能做到"要么都成功,要么都回滚"。
2. 状态机 + 条件更新(适合有明确状态流转的业务)
UPDATE orders
SET status = 'PAID', paid_at = NOW()
WHERE order_id = '12345'
AND status = 'UNPAID';
影响行数为 0 就说明已被处理过,直接 ACK。这比"先查再改"安全,因为查和改之间没有窗口。
3. Redis SETNX(快,但有边界)
Boolean first = redis.opsForValue()
.setIfAbsent("mq:order:" + orderId, "1", Duration.ofHours(24));
if (Boolean.FALSE.equals(first)) {
return; // 已处理
}
它的问题在于:Redis 宕机或数据过期后,幂等保护就失效了。适合对重复不敏感、只要求"短时间去重"的场景,不适合资金类业务。
一个反面案例:用"查询订单是否已支付"来做幂等判断。如果两笔重复消息几乎同时到达,两个消费者都查到"未支付",就都执行了支付逻辑。查询和写入之间没有原子性,这种幂等是假的。
五、坑三:顺序消息用错了范围
"我要保证消息顺序"这句话必须先回答一个问题:保证谁和谁之间的顺序?
- 全局顺序:所有消息严格按发送顺序处理。代价是只能单分区、单消费者,吞吐直接退化为单线程。
- 分区顺序:同一个业务键(比如订单号)的消息有序,不同订单之间无序。这是 99% 的场景真正需要的。
- 无序:绝大多数通知类消息其实不需要顺序。
Kafka 的分区顺序靠 key 路由:
// 同一个 orderId 一定进同一个分区,从而保证分区内有序
producer.send(new ProducerRecord<>("order-events", orderId, payload));
注意这里的前提是生产端不能乱序。如果开了 retries 但没开 enable.idempotence,重试的消息可能插到后一条消息后面,顺序就破了。这就是幂等生产者除了去重之外的第二个作用。
RocketMQ 用 MessageQueueSelector 显式指定队列:
producer.send(msg, new MessageQueueSelector() {
@Override
public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
int idx = Math.abs(arg.hashCode()) % mqs.size();
return mqs.get(idx);
}
}, orderId);
RabbitMQ 想保证顺序,只能一个队列一个消费者,而且不能用 basicNack(requeue=true)——重新入队会把消息放到队尾,顺序直接乱掉。
还有两个隐蔽的顺序破坏点:
- 消费端多线程处理。拉了 100 条消息丢给线程池,处理完成顺序就随机了。要保序就得按 key 分组,组内串行、组间并行。
- 失败重试。某条消息处理失败进入重试队列,几分钟后重试成功,但此时后续消息早就处理完了,业务上看到的就是"状态倒退"。
六、积压之后:恢复速度比堆积上限更重要
消息队列出问题,最典型的形态不是"挂了",而是"积压了几千万条,消费速度跟不上生产速度"。
这时候要看的不是总积压量,而是净消费速率:
净消费速率 = 消费 TPS - 生产 TPS
预计恢复时间 = 当前积压量 / 净消费速率
如果净消费速率是负的,扩消费者也没用,得先限流生产端。
Kafka 查积压:
kafka-consumer-groups.sh --bootstrap-server broker:9092 \
--describe --group order-service
# 输出里的 LAG 列就是积压量;CONSUMER-ID 为空说明该分区没有活跃消费者
RocketMQ 查积压:
sh mqadmin consumerProgress -n 127.0.0.1:9876 -g order-service
扩消费者有两个硬约束,很多人踩:
- 消费者数不能超过分区数。Kafka 一个分区只能被同组的一个消费者消费,第 9 个消费者在 8 分区的 topic 上会一直空闲。
- 扩消费者可能触发再均衡,再均衡期间整个组停止消费。频繁扩缩容反而拖慢恢复。
真正有效的加速手段是提高单条消息的处理效率:批量写库、批量调用下游、把同步 RPC 改成异步。这些比加机器有效得多。
七、一张决策表
把前面的内容压缩成一张表,选型时按顺序问四个问题:
| 问题 | 答案 | 倾向 |
|---|---|---|
| 需要多方订阅、要能回放历史? | 是 | Kafka |
| 需要复杂路由(按 header、按通配符)? | 是 | RabbitMQ |
| 需要事务消息(本地事务 + 发消息原子)? | 是 | RocketMQ |
| 需要延迟消息(30 分钟未支付取消订单)? | 是 | RocketMQ(或 RabbitMQ TTL + 死信) |
| 积压会到千万级? | 是 | Kafka / RocketMQ,排除 RabbitMQ |
| 团队只有一两个人维护中间件? | 是 | 优先云托管版,别自建 |
补充几点实践经验:
- 不要一个集群承载所有业务。交易类和日志类混在一个 Kafka 集群里,某天日志暴涨会把交易消息的延迟拖垮。至少按重要性分两个集群。
- 消费者组名要带版本。改消费逻辑需要重新消费历史数据时,新建一个 group 从 earliest 开始,比重置现有 group 的 offset 安全得多。
- 消息体保持小。大消息(几百 KB 以上)会拖慢批量发送、放大网络抖动的影响。超过 100KB 的内容建议存对象存储,消息里只放引用。
- 保留时间按恢复需求定,不按磁盘容量定。Kafka 默认 7 天,如果一次故障的平均修复时间是 3 天,那 7 天是合理的;如果曾经因为一个 bug 三天后才发现数据错了,就需要更长的保留期。
写在最后
消息队列的坑基本集中在三个地方:以为配置了持久化就不会丢、以为消费逻辑写对了就不会重复、以为指定了 key 就一定有序。这三个"以为",对应的都是配置项和代码位置的细节。
选型时多花半天把语义对齐,比上线后写三个月的补偿任务划算。
- 点赞
- 收藏
- 关注作者
评论(0)