Appearance
5.1-1 如何保证消息不丢失:生产、存储、消费三段
所属:05 消息中间件 / 5.1 通用能力 分级:A 状态:◐ 初稿 关联:3.1-6、5.1-2、5.1-3、5.1-4、5.3-2、5.3-3、5.3-6、5.4-3、5.4-6、6.1-3、6.1-4
题型:原理 / 场景 / 排障
一句话结论:消息不丢必须三段闭环:生产端确认(Broker 明确回复“已收下”)、Broker 持久化 + 副本(落盘且不止一份)、消费端处理成功后再确认(手动 ack / 处理完再提交 offset)。任何一段断开都会丢,而且只要做了重试,就必然是“至少一次”,所以幂等是可靠性的另一半。工程上还要防“被动丢失”:TTL 过期、队列/磁盘满、retention 清理、死信未处理。
分层要点:
- 先定义“丢”发生在哪:① 生产端发出但 Broker 没收到(网络、超时、路由失败);② Broker 收到了但只在内存/PageCache,宕机前没落盘或没同步到副本;③ Broker 落盘了但被清理(TTL、队列上限、磁盘满、Kafka retention);④ 消费端拿到了但处理失败前就 ack/提交 offset;⑤ 消费端处理成功但结果没落库(业务侧丢)。
- 生产端要“确认 + 重试 + 可发现”:RabbitMQ 用 publisher confirm(异步确认,配合
mandatory+basic.return处理不可路由消息);RocketMQ 用同步发送并检查SendStatus(SEND_OK之外都要重试/告警);Kafka 用acks=all+retries+enable.idempotence=true。只“send 了不报错”不等于 Broker 收下了。 - Broker 要“落盘 + 多副本”:RabbitMQ 要 durable exchange/queue +
delivery_mode=2,集群用 quorum queue(Raft,多数派确认);RocketMQ 要SYNC_FLUSH刷盘 +SYNC_MASTER主从同步(或 DLedger);Kafka 要replication.factor>=3+min.insync.replicas>=2+acks=all+ 关闭 unclean 选举。单机持久化只能防进程崩溃,防不了磁盘/机器故障。 - 消费端要“处理成功再确认”:RabbitMQ 关掉 autoAck,业务成功后
basic.ack,失败basic.nack/抛异常走重试;RocketMQ 返回CONSUME_SUCCESS或RECONSUME_LATER;Kafka 关掉enable.auto.commit,处理完再提交 offset(或至少保证提交发生在处理之后)。先 ack 后处理 = at-most-once,必丢。 - “至少一次”是重试的必然结果:生产重试、Broker 重投、消费重试都会产生重复;Kafka 的幂等生产者只解决“单分区单会话重试去重”,事务解决“Kafka 内 consume-transform-produce + offset 原子”,跨 DB/跨服务仍然是 at-least-once + 幂等(5.1-2、5.4-6)。
- 被动丢失最容易被忽略:RabbitMQ 有 TTL、队列最大长度、内存告警(paging/block)、磁盘告警;RocketMQ 磁盘不足会进只读、消息过期(默认 72h)、重试 16 次进死信;Kafka 有
retention.ms/bytes、segment清理。这些不是“故障”,是配置,但同样丢消息。 - 监控要端到端:生产失败率/RT/重试数;Broker 磁盘、刷盘耗时、主从延迟、副本同步;消费 lag、重试队列长度、死信数量;再加业务侧对账(订单数 vs 消息数)。只看“发送成功”监控是自欺欺人。
- 可靠性是有成本的:同步刷盘、同步复制、
acks=all都会显著降吞吐、升延迟。正确做法是分级:资金/订单强可靠,日志/埋点可弱;核心链路用同步确认,非核心用异步 + 批量 + 对账兜底。不要全链路按最高规格配。
图/流程:
text
三段式:
Producer ──①确认──▶ Broker ──②落盘+副本──▶ 磁盘/从节点
▲ │
│ ▼
└──── 重试/告警 ── Consumer ◀──③处理成功再 ack ── 业务 DBtext
RabbitMQ 可靠链路:
publisher → exchange(durable)
→ queue(durable / quorum)
→ 持久化消息(delivery_mode=2)
→ confirm 回调(ack=true)
→ 不可路由:mandatory + basic.return
consumer → 手动 ack
→ 成功 basic.ack
→ 失败 basic.nack / 抛异常 → 重试队列 / 死信text
RocketMQ 可靠链路:
producer.send(msg) 同步
→ SendResult.status
SEND_OK
FLUSH_DISK_TIMEOUT
FLUSH_SLAVE_TIMEOUT
SLAVE_NOT_AVAILABLE
→ 非 SEND_OK:重试 / 换 Broker / 告警
broker:
CommitLog 顺序写
→ SYNC_FLUSH(刷盘成功才返回)
→ SYNC_MASTER(从节点同步成功才返回)
consumer:
→ 业务成功 CONSUME_SUCCESS
→ 失败 RECONSUME_LATER → %RETRY% → 16 次 → %DLQ%text
Kafka 可靠链路:
producer:
acks=all
retries=Integer.MAX
enable.idempotence=true
delivery.timeout.ms
broker:
replication.factor=3
min.insync.replicas=2
unclean.leader.election.enable=false
consumer:
enable.auto.commit=false
处理成功 → commitSync(offset)
isolation.level=read_committed(事务场景)版本/源码锚点:
- RabbitMQ 3.8+:quorum queue(Raft 多数派);3.9 起 classic mirrored queue 弃用,4.0 移除;publisher confirm 为 2.3+ 能力,Spring AMQP 用
publisher-confirm-type=correlated+ConfirmCallback/ReturnsCallback。 - RocketMQ 4.5+:DLedger(Raft)模式;4.9/5.x:
SYNC_FLUSH、SYNC_MASTER、asyncSend、SendStatus、%RETRY%/%DLQ%。 - Kafka 2.0+:
acks=all、min.insync.replicas、unclean.leader.election.enable=false默认;0.11+ 幂等生产者/事务;3.x KRaft。 - Spring Boot:
spring.rabbitmq.publisher-confirm-type=correlated、spring.rabbitmq.publisher-returns=true、spring.rabbitmq.listener.simple.acknowledge-mode=manual;spring.kafka.producer.acks=all、spring.kafka.producer.properties.enable.idempotence=true、spring.kafka.listener.ack-mode=manual_immediate。 - 存储侧:RocketMQ CommitLog/ConsumeQueue(5.3-2);Kafka segment/ISR(5.4-2、5.4-3)。
- RabbitMQ 3.8+:quorum queue(Raft 多数派);3.9 起 classic mirrored queue 弃用,4.0 移除;publisher confirm 为 2.3+ 能力,Spring AMQP 用
三端失败点与手段:
| 环节 | 会怎么丢 | 核心手段 | 关键配置 |
|---|---|---|---|
| 生产 | 网络超时、Broker 未落盘、路由失败 | 确认 + 重试 + 失败落库 | RabbitMQ confirm/return;RocketMQ SendStatus;Kafka acks=all |
| 存储 | 内存未刷盘、单副本、磁盘满、过期清理 | 持久化 + 多副本 + 容量告警 | SYNC_FLUSH/SYNC_MASTER;quorum;min.insync.replicas |
| 消费 | 先 ack 后失败、offset 提前提交、线程池丢任务 | 手动 ack、处理完提交、幂等 | acknowledge-mode=manual;enable.auto.commit=false |
| 业务 | 消费成功但 DB 回滚/写失败 | 本地事务 + 重试 + 对账 | 幂等表、outbox、补偿 |
- 三件套可靠性对照:
| 维度 | RabbitMQ | RocketMQ | Kafka |
|---|---|---|---|
| 生产确认 | publisher confirm | 同步 send + SendStatus | acks=all |
| 不可路由 | mandatory + basic.return | 路由由 Topic/Queue 决定 | 分区不存在直接失败 |
| 持久化 | durable + delivery_mode=2 | CommitLog + SYNC_FLUSH | 副本 + flush 由 OS/副本保证 |
| 副本 | quorum queue(Raft) | SYNC_MASTER / DLedger | ISR + min.insync.replicas |
| 消费确认 | basic.ack / nack | CONSUME_SUCCESS / RECONSUME_LATER | offset commit |
| 重试 | 重回队列 / 死信 | %RETRY% 16 级 → %DLQ% | 消费端自行重试 / 重平衡 |
| 天然重复 | 是 | 是 | 是 |
| 典型强可靠组合 | durable + quorum + manual ack | SYNC_FLUSH + SYNC_MASTER | acks=all + RF=3 + minISR=2 |
- 确认模式对比:
| 模式 | 语义 | 风险 | 适用 |
|---|---|---|---|
| 自动 ack / 自动提交 | at-most-once | 处理失败也确认 → 丢 | 日志、埋点 |
| 处理成功后手动 ack | at-least-once | 重复 | 绝大多数业务 |
| 事务 / 幂等生产 | 接近 exactly-once | 复杂、性能低 | 金融、账务 |
| 先 ack 后异步处理 | at-most-once | 异步任务失败即丢 | 不推荐 |
- 常见“丢消息”场景:
| 场景 | 根因 | 处理 |
|---|---|---|
| 发送返回成功但消息没了 | acks=1/异步发送未检查结果 | 改 acks=all,检查 SendStatus/confirm |
| Broker 重启丢一批 | 未持久化/异步刷盘 | durable + SYNC_FLUSH / quorum |
| 主节点宕机丢最新消息 | 异步复制 | SYNC_MASTER / min.insync.replicas |
| 消费者重启后消息不见 | 自动提交 offset | 关闭自动提交,处理完再提交 |
| 消费线程池满丢任务 | 提交后未处理 | 有界队列 + 拒绝策略 + 重试 |
| 消息过期 | TTL/retention | 评估保留时间,监控过期量 |
| 队列满被拒 | 最大长度/磁盘 | 扩容、限流、告警 |
| 重试耗尽进死信没人管 | 未监控 DLQ | DLQ 告警 + 人工/自动补偿 |
| 业务 DB 提交了消息没发 | 本地事务与发送不原子 | 本地消息表/事务消息(3.1-6、5.3-6) |
| 消息发了业务回滚 | 先发消息后提交事务 | outbox / 事务消息 |
深挖点(面试官常追的 6 个):
- publisher confirm 和事务有什么区别:confirm 是异步、轻量的“Broker 已接收”回执,可以批量、可以配
mandatory处理不可路由;AMQP 事务(txSelect/txCommit)是同步阻塞的,每条消息都要等 commit,吞吐差一个数量级。生产上几乎都用 confirm + return,不用事务。注意 confirm 只表示“Broker 接收/落盘策略满足”,不表示“消费者已处理”。 - RocketMQ 刷盘和主从怎么组合:
ASYNC_FLUSH + ASYNC_MASTER性能最好,但 Broker 掉电/主节点宕机可能丢最后一批;SYNC_FLUSH + SYNC_MASTER最稳,RT 明显上升;SYNC_FLUSH + ASYNC_MASTER防单机掉电但不防主节点磁盘损坏;DLedger 用 Raft 多数派,兼顾一致性与自动选主。没有“既最快又最不丢”的组合,按业务分级选。 - Kafka 的
acks=all为什么还需要min.insync.replicas:acks=all表示“ISR 里所有副本都写入”,但如果 ISR 只剩 Leader 一个(其他副本落后被踢出),acks=all也照样成功,此时 Leader 挂了就丢。min.insync.replicas=2要求至少 2 个副本在 ISR 才接受写入,两者配合才真正防丢;再关掉unclean.leader.election,避免落后副本当 Leader。 - 消费端先 ack 还是先处理:先处理成功再 ack 是 at-least-once,崩溃会重投,必须幂等;先 ack 再处理是 at-most-once,进程崩溃/异常就永久丢。Kafka 的
enable.auto.commit=true是“按时间自动提交”,在两次提交之间崩溃会重复,而处理失败也可能已经提交——所以业务消费一律关自动提交,处理完再commitSync。 - 消息中间件不丢 ≠ 业务不丢:生产端“DB 提交成功”和“消息发送成功”是两个操作,先发消息后回滚、或先提交后发送失败,都会不一致。可靠做法是本地消息表/outbox(业务与消息同库同事务,后台投递 + 重试 + 对账)或 RocketMQ 事务消息(半消息 + 本地事务 + 回查);消费端则用幂等表/唯一键保证重复不产生副作用。
- 被动丢失怎么防:把“过期、队列上限、磁盘水位、死信”当成一级监控项。RabbitMQ 配
x-max-length、TTL、内存/磁盘告警;RocketMQ 监控磁盘使用率(默认 85% 触发只读/告警)、消息保留时长、DLQ 数量;Kafka 监控retention、UnderReplicatedPartitions、OfflinePartitions。这些配置失误造成的丢失,比网络抖动更常见。
- publisher confirm 和事务有什么区别:confirm 是异步、轻量的“Broker 已接收”回执,可以批量、可以配
追问链:
- 消息不丢分几段? → 生产、存储、消费,外加业务侧。
- 生产端怎么保证? → 确认 + 重试 + 失败落库。
- RabbitMQ 生产确认? → publisher confirm。
- confirm 是同步还是异步? → 异步回调。
- 不可路由消息怎么发现? →
mandatory+basic.return。 - RabbitMQ 事务能用吗? → 能,但同步阻塞、性能差。
- RocketMQ 怎么确认? → 同步 send +
SendStatus。 SEND_OK就安全吗? → 还要看刷盘/主从配置。- Kafka 怎么确认? →
acks=all。 acks=1会丢吗? → Leader 挂且未同步会丢。acks=0呢? → 发出去就不管,最易丢。- Broker 怎么保证不丢? → 持久化 + 多副本。
- RabbitMQ 持久化三要素? → durable exchange、durable queue、delivery_mode=2。
- 持久化就一定不丢吗? → 还要看刷盘/副本,classic 队列可能未 fsync。
- quorum queue 是什么? → Raft 多数派复制队列。
- RocketMQ 刷盘策略? →
SYNC_FLUSH/ASYNC_FLUSH。 - 主从同步策略? →
SYNC_MASTER/ASYNC_MASTER。 - DLedger 解决什么? → Raft 选主 + 多数派写入。
- Kafka 副本怎么配? → RF=3、minISR=2、acks=all。
- minISR 作用? → 保证 ISR 至少 N 个才写入。
- ISR 只剩 Leader 会怎样? → 低于 minISR 拒绝写入。
- unclean 选举风险? → 落后副本当 Leader 丢消息。
- 消费端怎么保证? → 处理成功后手动 ack/提交。
- RabbitMQ ack 模式? → auto/manual/none。
- RocketMQ 消费结果? →
CONSUME_SUCCESS/RECONSUME_LATER。 - Kafka 自动提交的坑? → 处理未完成已提交。
- 先 ack 后处理会怎样? → at-most-once,失败即丢。
- 先处理后 ack 会怎样? → at-least-once,会重复。
- 重复怎么办? → 幂等(5.1-2)。
- 能 exactly-once 吗? → Kafka 内可以,跨系统难。
- Kafka 幂等生产者范围? → 单分区、单会话、重试去重。
- Kafka 事务解决什么? → 多分区写 + offset 原子提交。
- 跨 DB 怎么 exactly-once? → 基本做不到,用幂等 + 对账。
- 消息过期算丢吗? → 算,配置问题。
- 队列满了会怎样? → 拒绝/丢弃/阻塞,取决于配置。
- 磁盘满会怎样? → RocketMQ 只读、RabbitMQ 阻塞、Kafka 故障。
- 死信队列要监控吗? → 必须,否则等于丢。
- 怎么发现丢消息? → 端到端对账 + 发送/消费计数。
- 监控哪些指标? → 发送失败率、刷盘延迟、主从延迟、消费 lag、DLQ。
- 消息积压会丢吗? → 一般不丢,但可能过期/打满(5.1-4)。
- 生产重试会重复吗? → 会,需幂等。
- 消费重试会重复吗? → 会,需幂等。
- 重试次数怎么定? → 按业务容忍度,配死信兜底。
- 本地消息表怎么做? → 同事务写业务+消息,后台投递。
- 事务消息怎么做? → 半消息 + 本地事务 + 回查(5.3-6)。
- 先发消息还是先提交事务? → 都不安全,用 outbox/事务消息。
- RabbitMQ 镜像队列还能用吗? → 3.9 弃用,4.0 移除,改 quorum。
- 可靠性对性能影响多大? → 同步刷盘/复制降一个量级。
- 所有链路都要最强可靠吗? → 不,分级。
- 面试怎么总结? → 三段闭环 → 三件套配置 → 至少一次 + 幂等 → 被动丢失 → 业务一致性 → 分级取舍。
生产案例/取舍(示例,替换成你的项目):
- 订单消息用
acks=1,Kafka Leader 宕机丢了几百单;改acks=all+ RF=3 + minISR=2,并补对账。 - RabbitMQ 只设了 durable queue,消息没设
delivery_mode=2,重启后队列在、消息没了;补齐持久化三要素。 - RocketMQ
ASYNC_FLUSH + ASYNC_MASTER,机房断电丢最后 2 秒消息;核心 Topic 改SYNC_FLUSH + SYNC_MASTER。 - 消费者用自动 ack,处理抛异常也确认,退款消息丢失;改手动 ack + 重试 + 死信。
- Kafka
enable.auto.commit=true,批量处理到一半实例被 kill,offset 已提交;改手动提交 + 幂等。 - 消费线程池用无界队列,OOM 后任务全丢;改有界队列 + 拒绝落库 + 告警。
- 死信队列堆了 30 万条没人看,等于丢了 30 万条;加 DLQ 告警和补偿 Job。
- 消息 TTL 设 1 小时,下游故障 2 小时,恢复后消息全过期;调大 TTL + 积压告警。
- 先发消息再提交本地事务,事务回滚导致下游多发货;改本地消息表。
- 生产端 send 超时但实际成功,重试导致重复下单;用业务唯一键幂等。
- Broker 磁盘 90% 进入只读,生产全部失败;加容量水位告警和自动清理。
- 取舍:
acks=all/同步刷盘换可靠性,代价是 RT 与吞吐;quorum queue 换一致性,代价是资源与延迟;手动 ack 换不丢,代价是重复与幂等成本;事务消息换一致性,代价是复杂度与回查。
- 订单消息用
易错点:
- 认为消息不丢只是 Broker 的事。
- 认为发了没报错就等于 Broker 收到了。
- 认为
acks=1不会丢。 - 认为
acks=all不需要min.insync.replicas。 - 认为 ISR 永远有多个副本。
- 认为持久化队列就等于消息持久化。
- 认为 RabbitMQ 持久化消息一定已 fsync。
- 认为 RocketMQ 异步刷盘不会丢。
- 认为主从异步复制不会丢。
- 认为 Kafka 多副本就不会丢(还要看 minISR/unclean)。
- 认为自动 ack 也能保证不丢。
- 认为先 ack 后处理没问题。
- 认为手动 ack 不会重复。
- 认为重试不会产生重复。
- 认为 Kafka 幂等生产者能跨分区去重。
- 认为 Kafka 事务能覆盖外部数据库。
- 认为 exactly-once 可以端到端绝对成立。
- 认为消息过期不算丢。
- 认为队列满了会一直等。
- 认为死信队列不用管。
- 认为积压只会延迟不会丢。
- 认为本地事务和发消息天然一致。
- 认为先发消息再提交事务安全。
- 认为 confirm 等于消费成功。
- 认为 RabbitMQ 事务比 confirm 更好。
- 认为镜像队列仍是推荐方案。
- 认为可靠性配置没有性能代价。
- 认为所有业务都该用最高可靠级别。
30 秒口述稿:
消息不丢要三段闭环。生产端要拿到 Broker 的确认:RabbitMQ 用 publisher confirm 加 mandatory return,RocketMQ 同步发送看
SendStatus,Kafka 用acks=all加幂等生产者。Broker 端要落盘加多副本:RabbitMQ 用 durable 加delivery_mode=2、集群用 quorum queue,RocketMQ 用SYNC_FLUSH加SYNC_MASTER,Kafka 用 RF=3、minISR=2、关掉 unclean 选举。消费端要处理成功再 ack 或提交 offset,绝不能先确认。只要做了重试就是至少一次,所以必须配幂等。另外 TTL、队列上限、磁盘满、死信这些“被动丢失”也要监控,业务侧还要用本地消息表或事务消息保证 DB 和消息一致。
- 3 分钟展开顺序:结论(三段闭环 + 至少一次 + 幂等)→ 五个丢失点 → 生产端三件套确认机制 → Broker 持久化与副本(三件套对照)→ 消费端 ack/offset 时机 → 重复与 exactly-once 边界 → 被动丢失与监控 → 业务一致性(outbox/事务消息)→ 可靠性与吞吐的分级取舍。