Skip to content

5.1-2 消息重复消费与消费端幂等 ​

所属:05 消息中间件 / 5.1 通用能力 分级:A 状态:◐ 初稿 关联:3.1-6、4.1-10、5.1-1、5.1-3、5.1-4、5.3-8、5.4-4、5.4-6、6.1-7

  • 题型:场景 / 原理 / 排障

  • 一句话结论:重复消费是“至少一次”语义的必然产物,不可能靠调参消灭——生产重试、Broker 重投、Rebalance、offset 回退都会让同一条消息被处理多次。所以幂等不是优化项,而是消费端的必答题:用业务唯一键做判断,把幂等落在数据库唯一约束、状态机条件更新、去重表、乐观锁上,并且去重记录与业务写入必须在同一个本地事务里。MQ 自带的“幂等生产者”只管生产端重试去重,管不了消费端。

  • 分层要点:

    1. 重复从五个地方来:① 生产端超时重试,但第一次其实已成功;② Broker 没收到 ack,消息重新投递;③ 消费端处理成功但提交 offset 前崩溃/被 kill;④ Rebalance 导致分区被回收,未提交的 offset 回退;⑤ 人工重放、补偿 Job、DLQ 重投。这五种都无法通过“仔细写代码”消除。
    2. 幂等的定义是业务语义:同一业务键(订单号、支付流水号、bizNo)的消息,处理一次和处理 N 次,业务最终状态相同、副作用只发生一次。它不等于“消息不重复到达”,也不等于“数据库没写两次”——数据库可以写两次中间态,只要最终状态和外部副作用正确。
    3. 幂等键怎么选:优先用业务单据号 + 操作类型(如 orderId + PAY),由生产端生成并保证全局唯一;不要用消息 ID 当业务幂等键——重发会生成新消息 ID,去重直接失效。消息 ID 只适合做“传输层去重表”的主键,而业务幂等必须靠业务键。
    4. 四种落点,强度不同:数据库唯一索引(最强,insert 冲突即已处理);状态机条件更新(update ... where status = '待支付',天然幂等);去重表(唯一键 + 处理标记,适合没有天然唯一约束的操作);Redis SETNX(快,但有过期、主从延迟、集群切换问题,只能做前端拦截)。生产上通常是“Redis 挡一层 + DB 唯一约束兜底”。
    5. 去重表必须“先插入、再处理”:INSERT 唯一键成功 = 我拿到了处理权;冲突 = 别人已处理/正在处理,直接 ack。先 SELECT 再 INSERT 有并发竞态:两个消费者同时查到“不存在”,然后都去处理。并发场景还要么依赖唯一索引,要么加分布式锁(6.1-7)。
    6. 去重记录与业务写入要同事务:同一个库时,INSERT 去重记录 + 写业务 放在一个本地事务,提交即一致;如果先写去重记录、业务失败回滚,就会出现“标记已处理但业务没做”→ 消息被 ack 后永久丢失。跨库/跨服务无法同事务,改用状态机 + 本地消息表 + 补偿,不要硬套去重表。
    7. 状态机是最优雅的幂等:把业务设计成“只有特定状态才能迁移”,重复消息自然被 where status = ... 挡住。比如支付回调只在 WAIT_PAY 时改为 PAID;发货只在 PAID 时改为 SHIPPED。幂等不是加一张表,而是把业务写成可重入的。
    8. 非幂等的外部副作用要单独处理:调用支付、发短信、扣库存、调第三方 API,这些操作重复执行会出事故。手段是:给下游传业务幂等键(多数支付/银行接口支持 outTradeNo 去重)、调用前查单、调用后对账、失败用状态机 + 定时补偿。“消息幂等”和“下游幂等”是两件事,必须分别确认。
  • 图/流程:

text
重复来源:
  Producer ──超时重试──▶ Broker
     │                     │
     │              ack 丢失/消费超时
     │                     ▼
     └──────────────▶ Consumer ──处理成功但提交前崩溃──▶ 重投
                          │
                     Rebalance / offset 回退
                          │
                     人工重放 / DLQ 重投
text
去重表(先插入再处理):
  consume(msg)
    → bizKey = msg.orderId + ":" + msg.type
    → INSERT INTO msg_dedup(biz_key, status)
        唯一键冲突?
          ├─ 是 → 已处理/处理中 → 直接 ack
          └─ 否 → 执行业务
                    ├─ 成功 → 同事务更新 status=SUCCESS → ack
                    └─ 失败 → 回滚 → nack/重试
text
状态机幂等:
  UPDATE orders
     SET status = 'PAID'
   WHERE order_id = ?
     AND status = 'WAIT_PAY';
  affected_rows = 1 → 首次处理
  affected_rows = 0 → 已处理或状态非法 → 直接 ack
text
并发重复:
  实例 A ─┐
          ├─ 同时收到同一 bizKey
  实例 B ─┘
    → 唯一索引:只有一个 INSERT 成功
    → 或分布式锁:lock(bizKey) 串行化
    → 禁止“先 SELECT 不存在 → 两边都处理”
  • 版本/源码锚点:

    • Kafka 0.11+:enable.idempotence=true 只保证单分区、单生产者会话内重试不重复;事务(transactional.id + sendOffsetsToTransaction)保证“消费-处理-生产 + offset”原子,仍不覆盖外部 DB。
    • RocketMQ:消费失败 RECONSUME_LATER 进 %RETRY%,默认 16 次后进 %DLQ%;MessageExt.getMsgId()、getKeys()(业务键建议放 keys);4.x/5.x 均不做消费端自动去重。
    • RabbitMQ:basic.ack 丢失会重投,redelivered=true 可辅助判断;x-death 记录死信原因;Spring AMQP MessageProperties.getMessageId()。
    • Spring Kafka:DefaultErrorHandler + DeadLetterPublishingRecoverer;@KafkaListener 配 ackMode=MANUAL / MANUAL_IMMEDIATE;seek 可回退 offset。
    • MySQL 8.0:唯一索引、INSERT IGNORE、ON DUPLICATE KEY UPDATE、affected_rows;InnoDB 唯一键冲突会加锁,注意并发插入的间隙锁。
    • Redis 7:SET key value NX EX seconds、SETNX;Redisson RLock;集群模式下注意 key 的 slot 与主从异步复制。
  • 重复来源与表现:

来源触发条件表现能否消除
生产重试发送超时但实际成功同一业务消息两条不能,只能幂等
Broker 重投消费未 ack / 超时redelivered=true不能
提交前崩溃处理完未提交 offset重启后重放不能,只能缩短窗口
Rebalance分区被回收、offset 未提交一批消息重放不能,只能减少频率
消费重试业务异常同一条多次进入不能
人工/补偿重放、DLQ 重投成批重复不能
  • 幂等方案对比:
方案原理优点代价/坑适用
数据库唯一索引重复插入冲突最强、简单要求有天然唯一键;冲突加锁订单、支付、流水
状态机条件更新where status=旧状态天然幂等、无额外表要求状态可枚举订单、工单、审批
去重表唯一键 + 处理标记通用表膨胀、需清理、要同事务无天然唯一键的操作
Redis SETNX原子占位快、挡在前面过期/主从延迟/集群切换会漏高并发前置拦截
乐观锁版本号where version=?防并发覆盖需重试更新类操作
分布式锁串行化同 key强性能、锁超时、死锁并发重复严重时
  • 幂等键选择对比:
候选是否可用原因
消息 ID(msgId)❌ 作业务幂等键重发会生成新 ID,去重失效
消息 ID✅ 作传输去重表主键能识别“同一条消息”
业务单号 bizNo✅ 首选生产端生成、全局唯一、可追溯
业务单号 + 操作类型✅ 最稳同一单据的支付/退款/发货可区分
时间戳 / 随机数❌每次不同
数据库自增 ID❌消费端生成,重复消费会不同
  • 并发重复的处理:
手段做法注意
唯一索引直接 INSERT,冲突即退出冲突异常要捕获,不能当失败重试
INSERT IGNORE忽略冲突,看 affected_rows只适用于 MySQL
ON DUPLICATE KEY UPDATE幂等 upsert注意不要覆盖业务字段
分布式锁按 bizKey 加锁锁超时 < 业务执行时间会失效
单分区串行同一 key 路由到同一分区依赖 5.1-3 的顺序保证
  • 失效场景与定位:
现象根因处理
同一订单重复发货无幂等 / 用 msgId 去重改业务键 + 状态机
去重表有记录但业务没做去重与业务不同事务合并事务或改状态机
高并发下仍重复先查后插竞态唯一索引 / 分布式锁
Redis 去重失效key 过期 / 主从切换加 DB 兜底
重试后重复扣款下游不支持幂等键传 outTradeNo + 查单
Rebalance 后大批重复offset 提交太晚缩短处理时间、手动提交
去重表暴涨无清理策略按时间分区/TTL 归档
唯一键冲突被当异常重试异常未分类冲突视为“已处理”,直接 ack
幂等键不唯一用时间戳/随机数改用业务单号
跨库操作仍重复本地事务管不到状态机 + 补偿 + 对账
  • 深挖点(面试官常追的 6 个):

    1. 为什么 MQ 不保证“只消费一次”:MQ 的投递语义是 at-least-once——Broker 只有在收到 ack 后才认为消费成功,而“处理成功”和“ack 到达 Broker”之间必然有窗口;网络分区、进程崩溃、Rebalance 都会让 ack 丢失,Broker 只能重投。要做到 at-most-once 就得先 ack 后处理,代价是丢消息。可靠性与不重复不可兼得,所以选不丢 + 幂等。
    2. 去重表为什么必须先 INSERT:唯一索引是数据库层面的原子操作,INSERT 成功即“抢到处理权”,冲突即“已有人处理”。如果先 SELECT 判断不存在再 INSERT,两个消费者会在同一时刻都读到“不存在”,然后都执行业务——这是典型的 check-then-act 竞态。正确姿势是让数据库的唯一约束来裁决。
    3. 去重记录和业务为什么必须同事务:如果先写去重记录并提交,再执行业务,业务失败时消息已经“被标记处理”,重试会被去重表挡住 → 业务永久丢失。同库时放一个本地事务;跨库时不能靠去重表,要用“业务状态机 + 本地消息表 + 定时补偿”,保证任何中间态都能被推进。
    4. Redis 去重能不能单独用:不能。Redis 主从是异步复制,主节点写入后宕机可能丢 key;key 有 TTL,过期后重复消息会穿透;集群 slot 迁移期间也可能出现异常。它适合做第一层拦截(挡住绝大多数重复、保护 DB),但最终一致性必须由数据库唯一约束/状态机兜底。
    5. 状态机幂等和去重表怎么选:有明确状态流转的业务(订单、支付、审批)优先状态机——它不引入新表、天然可重入、还能防非法状态跳转;没有状态概念的操作(发短信、写日志、调外部接口)才用去重表。两者可以叠加:状态机挡业务重复,去重表挡外部调用重复。
    6. 下游不幂等怎么办:先确认下游是否支持幂等键(支付、银行、物流大多支持 outTradeNo/requestId);不支持就用“调用前查单 + 调用后对账 + 状态机 + 人工补偿”。不要假设“我这边只调一次”——超时重试、网络抖动都会让下游收到多次。最终兜底一定是对账,而不是相信任何一层的“恰好一次”。
  • 追问链:

    1. 消息会重复吗? → 会,至少一次语义。
    2. 为什么会重复? → 重试、ack 丢失、Rebalance、offset 回退。
    3. 能靠配置消灭吗? → 不能。
    4. 什么是幂等? → 同一业务键多次处理,结果一致。
    5. 幂等键用什么? → 业务单号 + 操作类型。
    6. 能用消息 ID 吗? → 不能作业务键,重发会变。
    7. 消息 ID 有什么用? → 传输层去重表主键。
    8. 幂等落在哪? → DB 唯一索引、状态机、去重表、乐观锁。
    9. 最强的是哪个? → 数据库唯一约束。
    10. 为什么? → 原子、持久、跨实例。
    11. 去重表怎么建? → biz_key 唯一索引 + 状态 + 时间。
    12. 先查还是先插? → 先插,靠唯一键裁决。
    13. 先查后插有什么问题? → 并发竞态。
    14. 插入冲突怎么办? → 视为已处理,直接 ack。
    15. 去重表和业务要同事务吗? → 同库必须同事务。
    16. 不同事务会怎样? → 标记了但业务没做,消息丢。
    17. 跨库怎么办? → 状态机 + 本地消息表 + 补偿。
    18. 状态机怎么幂等? → where status=旧状态,看影响行数。
    19. 影响行数 0 怎么办? → 已处理,ack。
    20. Redis 去重行不行? → 只能做前置拦截。
    21. 为什么? → 过期、主从延迟、集群切换。
    22. Redis 用什么命令? → SET NX EX。
    23. key 怎么设计? → biz:type:id,带过期。
    24. 过期时间怎么定? → 覆盖最大重投窗口。
    25. 并发重复怎么防? → 唯一索引或分布式锁。
    26. 分布式锁注意什么? → 锁超时、续期、误删。
    27. 同一 key 能串行吗? → 路由到同一分区(5.1-3)。
    28. 消费失败重试会重复吗? → 会,必须幂等。
    29. Rebalance 会重复吗? → 会,offset 未提交就重放。
    30. 怎么减少? → 缩短处理、手动提交、max.poll.interval。
    31. 批量消费怎么提交? → 处理完再提交,注意批次边界。
    32. Kafka 幂等生产者解决什么? → 生产端重试去重。
    33. 能解决消费重复吗? → 不能。
    34. Kafka 事务解决什么? → 多分区写 + offset 原子。
    35. 能覆盖外部 DB 吗? → 不能。
    36. RocketMQ 自动去重吗? → 不去重。
    37. RabbitMQ 呢? → 不保证,redelivered 只是提示。
    38. 下游不幂等怎么办? → 传幂等键 + 查单 + 对账。
    39. 支付重复扣款怎么防? → outTradeNo + 状态机 + 对账。
    40. 发短信重复怎么办? → 去重表 + 频控。
    41. 扣库存怎么幂等? → 流水表唯一键 / 状态机。
    42. 幂等表会膨胀吗? → 会,按时间清理/归档。
    43. 清理后重复消息怎么办? → 保留窗口 > 最大重投周期。
    44. 唯一键冲突是异常吗? → 是数据库异常,但业务上是正常分支。
    45. 冲突后要重试吗? → 不要,直接 ack。
    46. 幂等和顺序有关系吗? → 有,乱序会让状态机判断错(5.1-3)。
    47. 幂等和积压有关系吗? → 积压重放会放大重复(5.1-4)。
    48. 怎么验证幂等有效? → 压测重放、故障注入、对账。
    49. 幂等有性能代价吗? → 一次额外写/查,通常可接受。
    50. 面试怎么总结? → 重复不可避免 → 业务键 → 唯一约束/状态机 → 同事务 → 并发与下游 → 对账兜底。
  • 生产案例/取舍(示例,替换成你的项目):

    • 支付回调重复通知,订单被重复标记发货;改为 update ... where status='PAID',影响行数为 0 直接返回成功。
    • 用 msgId 做去重键,生产端超时重试生成新 ID,重复扣款;改用 orderId + PAY。
    • 去重表先写后执行业务,业务异常回滚但去重记录已提交,消息被 ack 后订单永久未处理;改为同事务。
    • 两个实例同时消费同一 key,先查后插都判断“不存在”,重复发券;加唯一索引 + 捕获冲突。
    • Redis 去重 key 设 10 分钟过期,下游故障重投跨越 30 分钟,重复执行;DB 唯一约束兜底。
    • Redis 主从切换丢 key,短时间内重复消费;同上,加 DB 兜底。
    • Kafka 批量消费处理一半 Rebalance,整批重放;改手动提交 + 幂等。
    • 消费线程池异步处理,主线程已提交 offset,异步任务失败消息丢失;改同步处理或异步结果回写 + 重试。
    • 调第三方退款接口超时重试,下游重复退款;传 outRefundNo 并查单。
    • 去重表一年涨到 8 亿行,查询变慢;按 create_time 分区 + 90 天归档。
    • 唯一键冲突被全局异常处理器包成“系统错误”,触发无限重试;改为识别 DuplicateKeyException 直接 ack。
    • 取舍:唯一索引换强一致,代价是冲突加锁与写放大;Redis 换性能,代价是一致性弱;状态机换优雅,代价是建模成本;分布式锁换串行,代价是吞吐;同事务换一致,代价是事务变长。
  • 易错点:

    • 认为 MQ 能保证“只消费一次”。
    • 认为消费端不会重复。
    • 认为调大重试次数不会带来重复。
    • 认为消息 ID 可以做业务幂等键。
    • 认为重发消息的 ID 不变。
    • 认为幂等就是“消息只到达一次”。
    • 认为幂等只加一张去重表就行。
    • 认为先查后插没有并发问题。
    • 认为唯一键冲突应该重试。
    • 认为去重记录可以先提交、业务后做。
    • 认为去重表和业务不在一个库也能同事务。
    • 认为 Redis 去重可以单独使用。
    • 认为 Redis key 不会丢。
    • 认为 Redis 去重没有过期问题。
    • 认为分布式锁能替代唯一索引。
    • 认为状态机更新不需要看影响行数。
    • 认为 update 一定成功。
    • 认为消费失败重试不会重复。
    • 认为 Rebalance 不会导致重复。
    • 认为自动提交 offset 更安全。
    • 认为 Kafka 幂等生产者能解决消费重复。
    • 认为 Kafka 事务能覆盖外部数据库。
    • 认为 RocketMQ 会自动去重。
    • 认为 redelivered=true 就一定是重复。
    • 认为下游接口天然幂等。
    • 认为超时重试下游只收到一次。
    • 认为对账是可有可无的。
    • 认为所有操作都能做到强幂等。
  • 30 秒口述稿:

消息重复是至少一次语义的必然结果:生产超时重试、Broker 没收到 ack、消费处理完没提交 offset、Rebalance、人工重放,都会让同一条消息被处理多次,靠调参消灭不了。所以消费端必须幂等。幂等的判断要用业务键,比如订单号加操作类型,不能用消息 ID——重发会生成新 ID。落点上,有天然唯一键就用数据库唯一索引,有状态流转就用 where status=旧状态 的条件更新,没有就用去重表,但去重表必须先插入再处理,而且要和业务写在同一个事务里。Redis 只能做前置拦截,因为会过期、主从会丢。并发重复要么靠唯一索引裁决,要么加分布式锁。最后,下游不幂等的话还要传幂等键、查单和对账兜底。

  • 3 分钟展开顺序:结论(重复不可避免 + 幂等必答)→ 五个重复来源 → 幂等的业务语义与幂等键选择 → 四种落点及强度 → 去重表“先插入 + 同事务” → 并发重复的两种解法 → 状态机幂等的写法 → 跨库/跨服务的边界 → 下游非幂等操作的处理 → 监控、清理与对账兜底。