Skip to content

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 清理、死信未处理。

  • 分层要点:

    1. 先定义“丢”发生在哪:① 生产端发出但 Broker 没收到(网络、超时、路由失败);② Broker 收到了但只在内存/PageCache,宕机前没落盘或没同步到副本;③ Broker 落盘了但被清理(TTL、队列上限、磁盘满、Kafka retention);④ 消费端拿到了但处理失败前就 ack/提交 offset;⑤ 消费端处理成功但结果没落库(业务侧丢)。
    2. 生产端要“确认 + 重试 + 可发现”:RabbitMQ 用 publisher confirm(异步确认,配合 mandatory + basic.return 处理不可路由消息);RocketMQ 用同步发送并检查 SendStatus(SEND_OK 之外都要重试/告警);Kafka 用 acks=all + retries + enable.idempotence=true。只“send 了不报错”不等于 Broker 收下了。
    3. 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 选举。单机持久化只能防进程崩溃,防不了磁盘/机器故障。
    4. 消费端要“处理成功再确认”:RabbitMQ 关掉 autoAck,业务成功后 basic.ack,失败 basic.nack/抛异常走重试;RocketMQ 返回 CONSUME_SUCCESS 或 RECONSUME_LATER;Kafka 关掉 enable.auto.commit,处理完再提交 offset(或至少保证提交发生在处理之后)。先 ack 后处理 = at-most-once,必丢。
    5. “至少一次”是重试的必然结果:生产重试、Broker 重投、消费重试都会产生重复;Kafka 的幂等生产者只解决“单分区单会话重试去重”,事务解决“Kafka 内 consume-transform-produce + offset 原子”,跨 DB/跨服务仍然是 at-least-once + 幂等(5.1-2、5.4-6)。
    6. 被动丢失最容易被忽略:RabbitMQ 有 TTL、队列最大长度、内存告警(paging/block)、磁盘告警;RocketMQ 磁盘不足会进只读、消息过期(默认 72h)、重试 16 次进死信;Kafka 有 retention.ms/bytes、segment 清理。这些不是“故障”,是配置,但同样丢消息。
    7. 监控要端到端:生产失败率/RT/重试数;Broker 磁盘、刷盘耗时、主从延迟、副本同步;消费 lag、重试队列长度、死信数量;再加业务侧对账(订单数 vs 消息数)。只看“发送成功”监控是自欺欺人。
    8. 可靠性是有成本的:同步刷盘、同步复制、acks=all 都会显著降吞吐、升延迟。正确做法是分级:资金/订单强可靠,日志/埋点可弱;核心链路用同步确认,非核心用异步 + 批量 + 对账兜底。不要全链路按最高规格配。
  • 图/流程:

text
三段式:
  Producer ──①确认──▶ Broker ──②落盘+副本──▶ 磁盘/从节点
      ▲                   │
      │                   ▼
      └──── 重试/告警 ── Consumer ◀──③处理成功再 ack ── 业务 DB
text
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)。
  • 三端失败点与手段:

环节会怎么丢核心手段关键配置
生产网络超时、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、补偿
  • 三件套可靠性对照:
维度RabbitMQRocketMQKafka
生产确认publisher confirm同步 send + SendStatusacks=all
不可路由mandatory + basic.return路由由 Topic/Queue 决定分区不存在直接失败
持久化durable + delivery_mode=2CommitLog + SYNC_FLUSH副本 + flush 由 OS/副本保证
副本quorum queue(Raft)SYNC_MASTER / DLedgerISR + min.insync.replicas
消费确认basic.ack / nackCONSUME_SUCCESS / RECONSUME_LATERoffset commit
重试重回队列 / 死信%RETRY% 16 级 → %DLQ%消费端自行重试 / 重平衡
天然重复是是是
典型强可靠组合durable + quorum + manual ackSYNC_FLUSH + SYNC_MASTERacks=all + RF=3 + minISR=2
  • 确认模式对比:
模式语义风险适用
自动 ack / 自动提交at-most-once处理失败也确认 → 丢日志、埋点
处理成功后手动 ackat-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评估保留时间,监控过期量
队列满被拒最大长度/磁盘扩容、限流、告警
重试耗尽进死信没人管未监控 DLQDLQ 告警 + 人工/自动补偿
业务 DB 提交了消息没发本地事务与发送不原子本地消息表/事务消息(3.1-6、5.3-6)
消息发了业务回滚先发消息后提交事务outbox / 事务消息
  • 深挖点(面试官常追的 6 个):

    1. publisher confirm 和事务有什么区别:confirm 是异步、轻量的“Broker 已接收”回执,可以批量、可以配 mandatory 处理不可路由;AMQP 事务(txSelect/txCommit)是同步阻塞的,每条消息都要等 commit,吞吐差一个数量级。生产上几乎都用 confirm + return,不用事务。注意 confirm 只表示“Broker 接收/落盘策略满足”,不表示“消费者已处理”。
    2. RocketMQ 刷盘和主从怎么组合:ASYNC_FLUSH + ASYNC_MASTER 性能最好,但 Broker 掉电/主节点宕机可能丢最后一批;SYNC_FLUSH + SYNC_MASTER 最稳,RT 明显上升;SYNC_FLUSH + ASYNC_MASTER 防单机掉电但不防主节点磁盘损坏;DLedger 用 Raft 多数派,兼顾一致性与自动选主。没有“既最快又最不丢”的组合,按业务分级选。
    3. Kafka 的 acks=all 为什么还需要 min.insync.replicas:acks=all 表示“ISR 里所有副本都写入”,但如果 ISR 只剩 Leader 一个(其他副本落后被踢出),acks=all 也照样成功,此时 Leader 挂了就丢。min.insync.replicas=2 要求至少 2 个副本在 ISR 才接受写入,两者配合才真正防丢;再关掉 unclean.leader.election,避免落后副本当 Leader。
    4. 消费端先 ack 还是先处理:先处理成功再 ack 是 at-least-once,崩溃会重投,必须幂等;先 ack 再处理是 at-most-once,进程崩溃/异常就永久丢。Kafka 的 enable.auto.commit=true 是“按时间自动提交”,在两次提交之间崩溃会重复,而处理失败也可能已经提交——所以业务消费一律关自动提交,处理完再 commitSync。
    5. 消息中间件不丢 ≠ 业务不丢:生产端“DB 提交成功”和“消息发送成功”是两个操作,先发消息后回滚、或先提交后发送失败,都会不一致。可靠做法是本地消息表/outbox(业务与消息同库同事务,后台投递 + 重试 + 对账)或 RocketMQ 事务消息(半消息 + 本地事务 + 回查);消费端则用幂等表/唯一键保证重复不产生副作用。
    6. 被动丢失怎么防:把“过期、队列上限、磁盘水位、死信”当成一级监控项。RabbitMQ 配 x-max-length、TTL、内存/磁盘告警;RocketMQ 监控磁盘使用率(默认 85% 触发只读/告警)、消息保留时长、DLQ 数量;Kafka 监控 retention、UnderReplicatedPartitions、OfflinePartitions。这些配置失误造成的丢失,比网络抖动更常见。
  • 追问链:

    1. 消息不丢分几段? → 生产、存储、消费,外加业务侧。
    2. 生产端怎么保证? → 确认 + 重试 + 失败落库。
    3. RabbitMQ 生产确认? → publisher confirm。
    4. confirm 是同步还是异步? → 异步回调。
    5. 不可路由消息怎么发现? → mandatory + basic.return。
    6. RabbitMQ 事务能用吗? → 能,但同步阻塞、性能差。
    7. RocketMQ 怎么确认? → 同步 send + SendStatus。
    8. SEND_OK 就安全吗? → 还要看刷盘/主从配置。
    9. Kafka 怎么确认? → acks=all。
    10. acks=1 会丢吗? → Leader 挂且未同步会丢。
    11. acks=0 呢? → 发出去就不管,最易丢。
    12. Broker 怎么保证不丢? → 持久化 + 多副本。
    13. RabbitMQ 持久化三要素? → durable exchange、durable queue、delivery_mode=2。
    14. 持久化就一定不丢吗? → 还要看刷盘/副本,classic 队列可能未 fsync。
    15. quorum queue 是什么? → Raft 多数派复制队列。
    16. RocketMQ 刷盘策略? → SYNC_FLUSH / ASYNC_FLUSH。
    17. 主从同步策略? → SYNC_MASTER / ASYNC_MASTER。
    18. DLedger 解决什么? → Raft 选主 + 多数派写入。
    19. Kafka 副本怎么配? → RF=3、minISR=2、acks=all。
    20. minISR 作用? → 保证 ISR 至少 N 个才写入。
    21. ISR 只剩 Leader 会怎样? → 低于 minISR 拒绝写入。
    22. unclean 选举风险? → 落后副本当 Leader 丢消息。
    23. 消费端怎么保证? → 处理成功后手动 ack/提交。
    24. RabbitMQ ack 模式? → auto/manual/none。
    25. RocketMQ 消费结果? → CONSUME_SUCCESS/RECONSUME_LATER。
    26. Kafka 自动提交的坑? → 处理未完成已提交。
    27. 先 ack 后处理会怎样? → at-most-once,失败即丢。
    28. 先处理后 ack 会怎样? → at-least-once,会重复。
    29. 重复怎么办? → 幂等(5.1-2)。
    30. 能 exactly-once 吗? → Kafka 内可以,跨系统难。
    31. Kafka 幂等生产者范围? → 单分区、单会话、重试去重。
    32. Kafka 事务解决什么? → 多分区写 + offset 原子提交。
    33. 跨 DB 怎么 exactly-once? → 基本做不到,用幂等 + 对账。
    34. 消息过期算丢吗? → 算,配置问题。
    35. 队列满了会怎样? → 拒绝/丢弃/阻塞,取决于配置。
    36. 磁盘满会怎样? → RocketMQ 只读、RabbitMQ 阻塞、Kafka 故障。
    37. 死信队列要监控吗? → 必须,否则等于丢。
    38. 怎么发现丢消息? → 端到端对账 + 发送/消费计数。
    39. 监控哪些指标? → 发送失败率、刷盘延迟、主从延迟、消费 lag、DLQ。
    40. 消息积压会丢吗? → 一般不丢,但可能过期/打满(5.1-4)。
    41. 生产重试会重复吗? → 会,需幂等。
    42. 消费重试会重复吗? → 会,需幂等。
    43. 重试次数怎么定? → 按业务容忍度,配死信兜底。
    44. 本地消息表怎么做? → 同事务写业务+消息,后台投递。
    45. 事务消息怎么做? → 半消息 + 本地事务 + 回查(5.3-6)。
    46. 先发消息还是先提交事务? → 都不安全,用 outbox/事务消息。
    47. RabbitMQ 镜像队列还能用吗? → 3.9 弃用,4.0 移除,改 quorum。
    48. 可靠性对性能影响多大? → 同步刷盘/复制降一个量级。
    49. 所有链路都要最强可靠吗? → 不,分级。
    50. 面试怎么总结? → 三段闭环 → 三件套配置 → 至少一次 + 幂等 → 被动丢失 → 业务一致性 → 分级取舍。
  • 生产案例/取舍(示例,替换成你的项目):

    • 订单消息用 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/事务消息)→ 可靠性与吞吐的分级取舍。