> For the complete documentation index, see [llms.txt](https://gists.lanlance.cn/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://gists.lanlance.cn/cs/mq.md).

# 消息队列

## 1. 消息队列解决什么问题？什么情况下不该用？

* **异步处理**：把不影响当前请求结果的工作移出同步链路，比如下单后发通知、发优惠券。接口耗时立刻降下来，但后台工作并没有消失，业务全部完成的时间也未必缩短。
* **削峰填谷**：生产速率短时超过消费能力时，队列先把消息存下来，消费者按下游承受能力慢慢处理。注意这只对短时突发有效，如果长期生产速率 > 消费速率，积压只会越来越大，最终必须限流、扩容或减少工作量。
* **服务解耦**：生产者只管发布业务事件，下游谁订阅、怎么消费、怎么演进都互不影响。但双方仍依赖消息的字段、含义和版本，改协议还是要有兼容方案。

代价也要能答出来：

1. **可用性**：多了一个 Broker 依赖，MQ 挂了业务链路就断，需要集群高可用。
2. **一致性**：重复投递、乱序、消费失败都要业务自己治理（幂等、顺序、补偿）。
3. **复杂度**：多了一套中间件要部署、监控、运维。

**不该用的场景**：请求必须立刻拿到结果（如扣库存、支付扣款），不能把 " 已入队 " 当成 " 业务成功 " 返回给用户；要么同步做，要么把接口语义改成 " 受理成功 + 状态查询 "。单进程内的简单后台任务，也没必要引入独立 MQ。

## 2. Kafka、RocketMQ、RabbitMQ、Pulsar 怎么选？

先看需求：消息量级、延迟要求、要不要回放、顺序粒度、延迟消息和重试怎么处理，再看团队已有设施和运维能力。

| 产品       | 适合场景                      | 架构原因                         | 注意点                                             |
| -------- | ------------------------- | ---------------------------- | ----------------------------------------------- |
| Kafka    | 高吞吐事件流、日志采集、流计算、多消费组独立回放  | 分区日志 + 位点，消费不删数据             | 单条重试、延迟调度要业务自建；分区数和热点影响并行度                      |
| RocketMQ | 业务事件、事务消息、定时消息、按消息重试、局部顺序 | 单 CommitLog 顺序写，业务功能全        | SDK 和消息模型 4.x / 5.x 有版本差异；事务消息不含下游事务            |
| RabbitMQ | 工作队列、灵活路由、逐条确认、已有 AMQP 生态 | Exchange 路由模型                | 区分 classic / quorum / stream；普通队列确认后即移除，不能当回放日志 |
| Pulsar   | 存算分离、多租户、服务层和存储层独立扩展      | Broker 无状态 + BookKeeper 存储日志 | 组件多、排障复杂；扩容仍有负载迁移成本                             |

选型别背 " 金融级、海量、吞吐高 " 这类定语，要说架构原因。Kafka 也能跑交易事件，RocketMQ 也能采集日志；比性能必须在相同消息大小、批量、压缩、复制、刷盘配置下压测，看积压后的读取能力和 P99。

## 3. Topic、Queue、Consumer Group 有什么区别？RabbitMQ 怎么路由？

Topic 是消息的逻辑分类，Queue 是消息排队和分配的物理单位，Consumer Group 是一组共同消费一个订阅的消费者。三者不是两种互斥的 " 消息模型 " 分类，是不同产品的不同实现：

* **Kafka**：一个 Topic 有多个 Partition；不同消费组各自维护位点、独立消费同一份日志。同一个消费组内，一个分区同一时刻只分配给一个消费者，一个消费者可以拿多个分区。
* **RocketMQ**：一个 Topic 下有多个 MessageQueue，4.x 集群模式按队列分配给消费者分摊，不同消费组独立消费。
* **RabbitMQ**：`Producer → Exchange → Binding → Queue → Consumer`。同一个队列上的多个消费者竞争消费（每条消息只给一个）；要多个订阅者都收到，就各自建队列绑定到 Exchange。

RabbitMQ 的 Exchange 类型：

| 类型      | 路由规则                           |
| ------- | ------------------------------ |
| direct  | routing key 与 binding key 精确匹配 |
| fanout  | 广播到所有绑定队列，不看 routing key       |
| topic   | 按点分词匹配，`*` 匹配一个词，`#` 匹配零个或多个词  |
| headers | 按消息头与绑定参数匹配                    |

默认 Exchange 名字是空字符串，拿队列名当 routing key 直投。所谓 Simple、Work、发布订阅、Routing、Topic 五种 " 工作模式 "，只是这些组件的不同用法，不用背成五套架构。

消费端三个关键点：

1. **手动 ACK**：处理成功再 ack，消息才从队列移除；连接断开时未 ack 的消息自动 requeue。
2. **prefetch**：限制 channel 上未确认的投递数，防止慢消费者把内存撑爆。官方建议 100～300；设 1 最保守但吞吐最低，且它本身不保证公平也不保证有序。
3. **nack/reject**：`requeue=true` 重新入队（可能立刻重投形成风暴，要配合重试计数或延迟）；`requeue=false` 且配了 DLX 就进死信，否则丢弃。

## 4. RocketMQ 事务消息怎么工作？和本地消息表（Outbox）怎么选？

事务消息保证的是**生产者本地事务和消息发送的原子性**，消费者那边的事务不在保证范围内。

流程：

1. 生产者发送**半消息**，Broker 保存并 ACK，此时消费者不可见。
2. 生产者执行本地数据库事务（比如插订单）。
3. 本地事务成功就 Commit，失败就 Rollback，拿不准就返回 Unknown。
4. Commit/Rollback 消息丢了（网络断、进程挂），Broker 定时**回查**生产者本地事务状态，再决定提交还是回滚。

4.x 底层实现：半消息实际写入内部 Topic `RMQ_SYS_TRANS_HALF_TOPIC`（原 Topic/QueueId 存在属性里）。Commit 时把消息转写到真实目标 Topic，并在 `RMQ_SYS_TRANS_OP_HALF_TOPIC` 记一笔标记半消息已处理；Rollback 只写 OP 标记，不向目标 Topic 发布。这里的 " 回滚 " 只是让消息不可见，不会替你回滚已经提交的数据库。

**回查要能答对，追问必考**：

* 回查可能打到生产者组的其他实例，所以本地事务结果必须落库（和业务变更同一个事务），不能放在原进程内存里。
* 事务还在执行中、查询暂时失败时返回 Unknown，别因为一次 " 查不到 " 就回滚。
* 回查有次数上限（4.9.x `transactionCheckMax` 默认 15 次），超了之后别指望 Broker 干等，必须告警 + 人工补偿。

**和 Outbox 的取舍**：

| 方案    | 原理                                 | 依赖               |
| ----- | ---------------------------------- | ---------------- |
| 事务消息  | 半消息协议 + 回查                         | Broker 可靠回查、超时治理 |
| 本地消息表 | 业务数据和待发送事件写同一个 DB 事务，提交后由任务/CDC 投递 | DB 事务、投递任务、积压治理  |

两者都要消费端幂等和异常补偿。已有数据库、允许异步投递，Outbox 优先；已有成熟的 RocketMQ 事务消息设施，就复用。两个方案都做不到跨库瞬时原子提交，别在面试里吹 " 要么都成功要么都失败 "。

## 5. 如何保证消息不丢失？Kafka 的 acks、ISR 怎么配置？

先定义 " 成功 " 是什么，再按生产 → 存储 → 消费三个阶段逐一堵漏。

### 生产端

* 同步/异步发送都要**处理结果**：异步必须检查回调，`send()` 返回不等于 Broker 已确认。超时意味着结果未知（可能已写入），重试可能造成重复，所以发送要带稳定业务 ID。
* **双写窗口**：先提交 DB 再发消息，进程在中间崩溃就漏发；先发消息再提交 DB，DB 回滚后消费者可能已执行。解法就是 Outbox 或事务消息（见第 4 题）。
* Outbox 投递拿到 Broker 确认才能标记已发送；ACK 丢了或标记前崩溃会补发，靠消费端幂等兜底。重试到上限不能直接删待发送记录，要告警 + 补偿。

### Broker 端

| 产品       | 可靠性配置                                                                                 |
| -------- | ------------------------------------------------------------------------------------- |
| Kafka    | 副本数 3 + `acks=all` + `min.insync.replicas=2` + `unclean.leader.election.enable=false` |
| RocketMQ | 同步刷盘（`SYNC_FLUSH`）+ 同步复制（SYNC\_MASTER），或 DLedger/Controller 多副本 raft                  |
| RabbitMQ | 消息 persistent + 队列 durable + publisher confirm；多副本用 quorum queue（镜像队列 4.0 已移除）        |

RabbitMQ 还有个路由坑：消息没匹配到任何队列也会收到 confirm ACK，要用 `mandatory=true` 监听 `basic.return` 兜底。

### Kafka 确认语义（高频追问）

* `acks=0`：不等确认，进 socket buffer 就算发完，Broker 收没收到不知道，最容易丢。
* `acks=1`：Leader 写入本地日志（page cache）就确认，Leader 挂了且 Follower 还没同步，消息就丢了。
* `acks=all`：等 ISR 里所有副本确认。注意**不是**只等 `min.insync.replicas` 个副本：3 个副本都在 ISR 时要 3 个都确认；`min.insync.replicas` 只是 ISR 数量跌破这个值时拒绝写入（抛 `NotEnoughReplicas`），宁可写不进也不丢。ISR 只剩 Leader 时，min=2 的配置会直接拒绝写。
* 常规起点：`replication.factor=3` + `min.insync.replicas=2` + `acks=all` + 禁脏选主，副本跨故障域部署。机器同时掉电、磁盘全坏这种超出保证范围。

### 消费端

* **先落库、再 ACK/提交 offset**。反了会丢：先提交 offset 再处理，崩溃后消息不会重投。
* 异步线程池消费时，" 任务已提交到线程池 " 不等于 " 业务已完成 "，offset 只能提交到**连续完成**的位置：101 没完成、102 完成了，最多提交 101，不能提交 103；恢复后重读 101、102，靠幂等去重。
* 注意保留期：Kafka/RocketMQ 都按策略清理旧消息，不会因为某个组没消费完就无限保留，要监控最老未消费消息年龄。消费端业务失败的问题见第 16 题，可靠入队救不了下游业务失败。

## 6. 重复消息为什么不可避免？业务幂等怎么做？

重复的来源：发送超时后补发、业务提交后 ACK 丢失、消费者故障/Rebalance 重投、人工回放。只要走 " 至少一次 " 投递，重复就是常态，目标是**同一业务操作只生效一次**。

### 幂等键怎么选

* 首选**业务操作唯一标识**：支付流水号，或 " 订单 ID + 操作类型 + 批次 "。只用订单 ID 会把同一订单后续的不同事件全拦掉。
* 稳定事件 ID 也可以（Outbox ID，补发不变）；如果同一业务操作可能产生不同事件 ID，还得靠业务唯一约束兜底。
* Broker 消息 ID 不稳定（重发路径可能换 ID），不能直接拿来去重。

### Inbox 模式（和业务一个事务）

业务结果落同一个数据库时，一个事务里做三件事：

1. 唯一约束插入去重记录（Inbox），靠插入成功/冲突处理并发，不能 " 先查再插 "。
2. 执行业务更新。扣库存就在 UPDATE 里带 `stock >= n` 条件，不能应用层先读再减。
3. 业务和去重记录一起提交，之后再 ACK/提交 offset。

拆开写就是两个坑：

| 拆分方式              | 崩溃后果                 |
| ----------------- | -------------------- |
| 先提交 " 已处理 "，再执行业务 | 标记成功但业务没执行，重试被拦住，漏执行 |
| 先提交业务，再记 " 已处理 "  | 业务生效但没标记，重试再扣一次      |

Redis `SET NX EX` 只能原子抢锁，锁过期时业务可能还在跑，也不能和 MySQL 更新放进一个事务。只做状态迁移的业务，可以用条件更新（`UPDATE … WHERE status='待支付'`，检查影响行数）代替独立去重表。

调支付、短信这类外部服务时，本地事务罩不住远程副作用，要么下游支持幂等键/结果查询，要么接受补偿，没法保证远程只执行一次。

面试追问：业务提交后确认失败怎么办？Outbox ID 为什么能做幂等键、一条 Redis 去重为什么不够？[牛客 / 阿里一面 / 原帖第 30、38 题 / 团队未注明](https://www.nowcoder.com/feed/main/detail/6b1e1f5809134975a7febbe76b756f5e)。

## 7. Kafka 的幂等生产者和事务（Exactly-Once）各保证什么？

### 幂等生产者

`enable.idempotence=true`（3.0 起默认开）：每个生产者有 PID + Epoch，每条消息带分区级序号，Broker 按序号去重，解决**协议重试**造成的重复写入。条件：`acks=all`、`retries>0`、`max.in.flight.requests.per.connection <= 5`（5 以内还能保证分区内不乱序）。

它管不了业务层重复调用 `send()`，也管不了普通生产者重启后的 " 相同内容 " 去重，那是业务幂等的事。

### Kafka 事务

典型场景是 "Kafka 进 → 处理 → Kafka 出 " 的流式处理（Kafka Streams 的 exactly-once 就是这套）：

1. 配置 `transactional.id`，`initTransactions()` 会拿到 Producer Epoch，旧实例再提交会被 fencing 挡掉。
2. `beginTransaction()` → 写输出消息 → `sendOffsetsToTransaction(offsets, groupMetadata)` 把输入的消费位点绑进事务 → `commitTransaction()`。
3. 输出消息和输入位点要么都生效要么都不生效，下游重跑同一批输入不会重复输出。
4. 消费端设 `isolation.level=read_committed`，只读已提交事务的消息。

细节：`read_committed` 受 LSO（Last Stable Offset）限制，分区上有未结束的事务时，它后面的消息也读不到。事务协调器向涉及分区写 Commit/Abort 标记来落地。**外部 MySQL、HTTP 调用、发短信都不在事务范围内**，旧实例已经发出去的短信也不会被 fencing 撤回，这些靠业务幂等。

## 8. 消息积压怎么排查、恢复？扩消费者一定有效吗？

先看分区的生产速率、消费速率、最老消息年龄，分清是持续容量不足、短时突发还是故障阻塞。只看 Topic 总 Lag 会掩盖单分区热点。

### 排查顺序

1. 消费者本身：掉组/反复 Rebalance、反序列化报错、毒消息死循环、分区被暂停。
2. 业务处理耗时：下游 RT、慢 SQL、锁等待、连接池、线程池、GC、磁盘网络。
3. 数据倾斜：是不是热点 Key 全挤在一个分区，其他分区早就追平。
4. 保留期和磁盘余量：快过期就先延长保留期争取时间（前提是磁盘有空间）。

### 恢复手段和它们的边界

* **扩消费者实例**：只在还有空闲分区可分时有效，Kafka 消费组实例数超过分区数就不起作用了。
* **批处理/缓存/合并请求**：瓶颈在逐条远程调用时优先考虑。加并发前先确认下游限额扛得住，别把积压变成下游雪崩。
* **单机多线程**：一个 KafkaConsumer 拉取线程 + 有界工作线程池（不能多线程并发调同一个 consumer），限制在途任务数、只提交连续完成的位点。
* **扩分区没用**：Kafka 加分区不迁移存量数据，热点分区的老积压还在原地，按 Key 路由还会变。
* **分区数卡死 + 积压巨大**（比如 4 分区积压千万条）：临时建一个 10 倍分区的新 Topic，把原消费者改成纯转发程序搬积压，再起 10 倍机器消费新 Topic。前提是没有顺序约束、下游可扩、准备好切换和核账方案；转发程序要保证目标 Topic 确认后才推进源位点（用 Kafka 事务把转发和位点绑成原子最稳）。这是个有代价的迁移方案，不是标准动作。

**消化积压的本质**是消费速率要持续大于生产速率：积压 B、生产 λ、消费 μ，恢复时间约等于 `B/(μ-λ)`。判断恢复别只看 Lag 归零，要看最老消息年龄、错误率和业务完成状态。

## 9. 如何保证消息有序？失败、扩容、Rebalance 会怎样？

先确定顺序粒度：通常只需要同一订单/账户/设备内有序，别上全局串行。整条链路要依次满足：**事件生成有序 → 发送有序 → 落到同一分区 → 消费按顺序处理**。

### 各产品实现

| 产品       | 做法                                                                                              |
| -------- | ----------------------------------------------------------------------------------------------- |
| Kafka    | 按 Key 哈希路由到固定分区，分区内天然有序，消费端串行或按 Key 串行。非幂等生产者重试 + in-flight > 1 会批次乱序；幂等生产者在 in-flight ≤ 5 内保序  |
| RocketMQ | 4.x 用 MessageQueueSelector 按 Key 选队列 + 顺序消费 Listener；5.x FIFO Topic + MessageGroup，组内 FIFO、组间并行 |
| RabbitMQ | 单队列 + 单活跃消费者 + 串行处理；`prefetch=1` 只限制在途数量，单独设它不等于有序                                              |

### 三个必考追问

1. **消费失败怎么保序**：严格顺序下，后面消息依赖前面成功。把失败消息丢进异步重试队列、继续消费后面的，顺序就破了。只能本地有限次重试 + **挂起当前队列/消息组**等它成功，超限进 DLQ 后告警人工处理。RocketMQ 顺序消费就是这么做的（挂起当前队列，SuspendCurrentQueueTimeMillis 控制重试间隔）。
2. **扩分区/队列数怎么保序**：分区数一变，同一 Key 的哈希落点就变。新分区的新消息可能先于老分区的积压被消费，造成乱序。解法是暂停相关写入、排空老分区再切换，或设计带版本的迁移屏障；一致性哈希只能减少 Key 迁移量，消不掉这个窗口。
3. **热点 Key**：大商户全哈希到一个分区，单分区顺序消费成为瓶颈。能缩粒度就缩（按订单 ID 局部有序代替按商户 ID），真的要求同一账户严格串行，只能优化单条处理耗时 + 控制输入速率。

另外 Rebalance 不改变日志内顺序，但旧实例的异步任务可能还在跑，分区移交时要停止派发、协调在途任务再提交，否则旧任务晚到会覆盖新实例的结果。

## 10. Kafka 为什么吞吐量高？零拷贝的前提是什么？

* **顺序追加写**：分区日志只追加不修改，避免磁盘随机寻址。注意别吹成 "Broker 永远顺序 IO"：大量分区交错写、冷读、日志压缩都会引入随机 IO。
* **批量 + 压缩**：生产端按分区攒 batch，消费端批量拉取，摊薄网络往返和系统调用。调大 `batch.size` / `linger.ms` 是常见优化，代价是内存和延迟。
* **Page Cache**：消息不进 JVM 堆，直接依赖 OS 文件缓存。追平日志的消费者基本全从 cache 读，磁盘零读请求；cache 里的数据还没刷盘，这是性能和可靠性的取舍点。
* **分区并行**：多 Broker、多磁盘、多消费者分摊负载，取决于分区分布是否均匀。

### 零拷贝（sendfile）与 mmap

传统文件发送到 socket 要 4 次拷贝、4 次上下文切换：`磁盘 → page cache（DMA）→ 用户缓冲区（CPU）→ socket 缓冲区（CPU）→ 网卡（DMA）`。

`sendfile` 系统调用跳过用户态往返：2 次上下文切换；网卡支持 SG-DMA（scatter-gather）时只剩 2 次 DMA 拷贝、0 次 CPU 拷贝，内核只传文件描述符和偏移量。

Kafka 里的分工：

* **消费端读 `.log`**：走 `FileChannel.transferTo`（即 sendfile），数据从 page cache 直接进网卡，这是 Kafka 真正的零拷贝。
* **索引文件 `.index` / `.timeindex`**：用 mmap（`MappedByteBuffer`）映射，把文件映射进用户态虚拟内存，省掉 read 的内核到用户态拷贝，适合小文件随机读。严格说 mmap 还有一段 CPU 拷贝，不算完全零拷贝；消息数据文件并不用 mmap 写。
* **TLS/SSL 一开，sendfile 失效**：加密在用户态做（内核态 `SSL_sendfile` Kafka 4.1 还不支持），数据必须读回用户态加密再发出，拷贝路径退回去。这是高吞吐集群通常跑 PLAINTEXT 的原因之一。

## 11. Kafka 的日志、索引、保留和回放怎么工作？

一个 Partition 一个日志目录，日志切成多个 Segment，文件名就是起始 offset（如 `00000000000000000000.log`）。每个 Segment 三件套：

| 文件           | 作用                                                       |
| ------------ | -------------------------------------------------------- |
| `.log`       | 消息数据（Record Batch），顺序追加                                  |
| `.index`     | 稀疏 offset 索引，每条约 8B（4B 相对 offset + 4B 物理位置），每写 4KB 日记建一条 |
| `.timeindex` | 稀疏时间戳索引，每条约 12B（8B 时间戳 + 4B 相对 offset），按时间找消息用           |

按 offset 查消息的路径：二分找 Segment → 在 `.index` 里二分找不大于目标 offset 的索引项 → 从物理位置顺序扫描 `.log`。索引是稀疏的，没有每条消息一项；Kafka 也不是按业务字段检索的数据库。

**位点独立于日志**：提交 offset 不删数据，消息按保留策略清理。新消费组、或把位点回拨，都能重放保留期内的数据，但业务副作用会再来一次，靠幂等。注意：已有有效位点时，`auto.offset.reset=earliest` 不会生效（该参数只管没有位点或位点越界的场景）。

清理策略：

* `delete`（默认）：按时间/大小删整个旧 Segment。清理是异步的，实际保留时间受 Segment 滚动周期影响。
* `compact`：按 Key 保留最新值，用于状态恢复（如 `__consumer_offsets`、changelog）。异步执行，不保证日志里只剩一条同 Key；也绝不能拿它当业务去重。
* tombstone（Key 的 value 为 null）表示删除该 Key，压缩后最终被清掉。
* `delete,compact` 组合时保留期限照样会删掉压缩后的记录，最新值不是永久存在的。

## 12. Kafka 和 RocketMQ 存储模型有什么区别？为什么 Topic 多了成本不一样？

| 维度        | Kafka                  | RocketMQ 4.x                                           |
| --------- | ---------------------- | ------------------------------------------------------ |
| 消息数据      | 每个 Partition 独立的分段日志文件 | 一个 Broker 所有 Topic/Queue 共享一条 CommitLog（1GB 一个文件，顺序追加） |
| 消费索引      | 分区 offset + 稀疏索引       | 每个 Topic/Queue 一条 ConsumeQueue，指向 CommitLog 的索引        |
| 按 Key 查消息 | 不提供                    | IndexFile 哈希索引，按 Key/时间查                               |
| 读路径       | 分区内连续读很自然              | ConsumeQueue 连续读，回 CommitLog 取正文是跨位置随机读                |

经典 ConsumeQueue 条目定长 20B：8B CommitLog 物理偏移 + 4B 消息长度 + 8B tag hashcode；一个文件约 30 万条、5.72MB。后台线程 `ReputMessageService` 顺序扫 CommitLog，异步构建 ConsumeQueue 和 IndexFile。

**为什么 Kafka 分区多了会退化为随机 IO**：每个 Partition 一个独立目录 + 独立 `.log`，几百上千个分区并发追加时，磁盘物理上就是一堆分散的写点，机械盘寻道开销爆炸；再加上海量文件句柄、索引、复制线程、元数据和选主恢复成本。RocketMQ 靠单 CommitLog 聚合写把追加点收成一个，多 Topic 场景顺序写不被打散，所以能扛万级队列。

注意 5.x 新架构（RocksDB ConsumeQueue 等）条目格式有变化，别把 20B 写死当所有版本的答案；也别说成 "RocketMQ 无上限 "，ConsumeQueue、索引、恢复都有成本。

## 13. Kafka 的 LEO、HW、LSO、Leader Epoch 分别是什么？

* **LEO（Log End Offset）**：该副本日志下一条消息的 offset，各副本可以不同。
* **HW（High Watermark）**：已提交消息的边界，消费者只能读到 HW 之前的消息。取 ISR 中最小的 LEO，由 Leader 推进后随 Fetch 响应传回 Follower。
* **LSO（Last Stable Offset）**：事务读取边界，`read_committed` 只能读到 LSO。有未结束事务时 LSO 停在最早未提交事务的起点，会挡住它后面的消息。
* **Leader Epoch**：每个 Leader 任期的编号 + 该任期起始 offset 的序列，存在每个副本的 checkpoint 文件里。

Follower 拉取数据，下一轮 Fetch 才报告进度，Leader 再推进 HW 传回来，所以**数据已复制到 Follower 和 Follower 知道新 HW 之间差一轮**。这个时间差就是老机制的坑：

1. **丢数据**：Follower 拉到了 m2（已在 ISR 中同步），但本地 HW 还没更新。此时 Follower 重启，按本地 HW 截断日志把 m2 删了；紧接着原 Leader 挂掉，这个 Follower 当选新 Leader，m2 永久丢失。
2. **副本分叉**：多次故障后，不同副本同一 offset 上存的是不同消息，严重时复制卡死。

**Leader Epoch 的修复**：Follower 重启后不再按本地 HW 截断，而是拿自己最新的 Epoch 问 Leader" 我这个任期到哪个 offset 结束 "，Leader 回一个权威位点，Follower 只截断和 Leader 日志分叉的部分再拉取。它解决的是日志一致性判断，救不了所有副本都丢数据的情况，也和 `unclean.leader.election` 是两码事。

别混淆三个 " 位点 "：HW 是副本提交边界，LSO 是事务读取边界，consumer 的 committed offset 是消费组的恢复位置。Lag 算的是哪种末端位置也要看清楚；事务控制消息和压缩的 offset 空洞会让 offset 差值不等于消息条数。

## 14. Kafka 怎么分配分区？Rebalance 为什么会影响消费？

### Classic 协议流程

1. `FindCoordinator`：消费者找到自己组的 Group Coordinator（Broker 端）。
2. `JoinGroup`：所有成员上报订阅和支持的分配策略，Coordinator 选出一个**消费者 Leader**（是消费组里的一个成员，不是 Partition Leader）和最终策略。
3. Leader 在客户端本地执行分配算法，把结果通过 `SyncGroup` 发给 Coordinator，Coordinator 再分发给所有成员。

分配算法放在客户端 Leader 做，是为了让自定义策略不用升级 Broker；KIP-848 新协议又改回服务端分配。

| 策略                        | 特点                    |
| ------------------------- | --------------------- |
| RangeAssignor             | 按 Topic 逐个分配连续区间      |
| RoundRobinAssignor        | 全部分区轮询分配，订阅一致时更均匀     |
| StickyAssignor            | 均衡的同时尽量保留原分配，减少迁移     |
| CooperativeStickyAssignor | 粘性 + 协作式增量移交，避免全组 STW |

**Range 的经典坑**：它按单个 Topic 独立算。两个消费者订阅 10 个 Topic、每个 3 个分区，每个 Topic 都是 C0 多拿 1 个分区，累计下来 C0 拿 20 个、C1 只拿 10 个，严重倾斜。分区数均衡也不等于流量均衡。

### Rebalance 触发与治理

触发条件：成员增减/被踢、订阅变化、Topic 分区数变化。Eager 模式（默认）会先撤销全组分区再重新分配，期间整组停止消费。

关键参数是两条线：`session.timeout.ms` 管心跳存活（心跳线程），`max.poll.interval.ms` 管两次 poll 的最大间隔（业务线程）。**业务处理太慢超过 max.poll.interval.ms，心跳再正常也会被踢出组**触发 Rebalance，这是生产上最常见的掉组原因。治理：

* 降低单批耗时、调小 `max.poll.records`，慢逻辑异步化（配合连续位点提交）。
* 滚动发布用**静态成员** `group.instance.id`（每实例唯一），短暂重启不触发 Rebalance。
* 换 `CooperativeStickyAssignor` 做增量再均衡。
* KIP-848 新 Consumer 协议（4.0 GA，`group.protocol=consumer`）：服务端分配 + 增量协调，没有全组同步屏障，heartbeat/session 参数改由 Broker 配置控制。

新协议解决的是协调停顿，慢业务、热点、重复消费还是要业务自己治理。

## 15. Kafka 怎么高可用？为什么弃用 ZooKeeper 改用 KRaft？

先分清两层：**数据副本**和**元数据管理**。

* 数据面：分区 Leader 读写、Follower 拉取复制，Leader 挂了由 Controller 协调选主（优先 ISR，配合第 5 题的 acks 配置保证不丢）。
* 控制面：Controller 管 Broker/Topic/分区/副本状态。Controller 可用不等于分区可用，反过来也一样。

**ZK 模式的问题**：元数据存 ZooKeeper，Kafka Controller 故障切换时要全量加载 ZK 元数据、给所有分区逐个发起选主和状态广播，分区数到几十万时恢复要几分钟；而且要运维两套分布式系统（Kafka + ZK）。

**KRaft**：把元数据变更写成一条内部 Raft 日志 `__cluster_metadata`，由 3 或 5 个 Controller 组成 quorum 复制；Active Controller 处理写，其他 Controller 实时跟随做**热备**，故障时秒级接替；Broker 订阅这条日志增量获取元数据。元数据规模不再受 ZK 单点加载限制。部署上 2N+1 个 Controller 容忍 N 个故障，生产环境别用 Broker+Controller 混合节点。Kafka 4.0 起彻底移除 ZK 模式。

两个容易吹错的地方：

* **KRaft 的 Raft 只用于元数据，业务分区仍然是分区多副本复制，没有改成 Raft 多数派写**。
* KIP-966 **ELR（Eligible Leader Replicas）**：4.0 引入、4.1 起新集群默认开。ISR 全挂时，Controller 可以从 ELR（已退出 ISR 但持有完整已提交前缀的副本）里选主，减少不可用窗口，且不等于脏选主。

## 16. 消费失败怎么重试？死信队列和 RocketMQ 过滤怎么工作？

失败分两类：临时性（网络抖动、下游短时不可用）可以退避重试；永久性（消息非法、业务规则拒绝）重试一万次也没用，要隔离 + 人工处理。

### RocketMQ（功能最全，对比着记）

* 4.x 集群并发消费失败，消费者把消息发回 Broker，进重试 Topic `%RETRY%<ConsumerGroup>`，按延迟梯度退避重投：10s、30s、1min、2min…2h，默认 16 次（可配），超限进死信 Topic `%DLQ%<ConsumerGroup>`，等人工介入。广播模式没有这套重试。
* 顺序消费失败不进重试队列（会破序），而是挂起当前队列原地重试（见第 9 题）。
* 5.x：PushConsumer 按消费结果和组配置重试；SimpleConsumer 用不可见时间（InvisibleDuration）控制何时重新可见，处理太久要主动延长。

### Kafka 和 RabbitMQ

* **Kafka**：以连续位点恢复，没有原生的单条 ACK/NACK 重试队列。做法是本地有限次重试后暂停分区，或把失败消息转发到自建重试/DLQ Topic 再推进源位点；转发没成功就提交源位点会漏，用 Kafka 事务把 " 转发 + 位点提交 " 绑成原子可以解决。
* **RabbitMQ**：DLX 是个普通 Exchange，消息 reject/nack（requeue=false）、TTL 过期、队列超长、quorum queue 超投递次数（delivery-limit）都会死信过去。注意：整队列过期（queue TTL）不会死信消息。quorum queue 支持至少一次死信转发（内部带 confirm 的死信消费者），比默认丢给 DLX 可靠。

### RocketMQ 消息过滤

* **Tag 过滤**：Broker 在 ConsumeQueue 里先比对 8B 的 tagsCode（hash），命中的再回 CommitLog 取出完整消息，由客户端按 Tag **原字符串**再精确匹配一次，防止哈希碰撞误投。两层都要答。
* **SQL92 属性过滤**：按消息自定义属性写表达式（`a between 0 and 3`），Broker 端求值，需开 `enablePropertyFilter=true`；有布隆过滤器做预筛加速。它不是任意 SQL，也不能查消息体。

## 17. 延迟消息怎么实现？订单超时关闭有哪些坑？

延迟消息给的是 " 到期可投递 " 的时间，不是 " 到期精确执行 "：调度、积压、消费者故障都会带来误差。

| 方案           | 做法                                                        | 限制                                           |
| ------------ | --------------------------------------------------------- | -------------------------------------------- |
| RocketMQ 4.x | 18 个固定延迟级别（1s、5s、30s…2h），消息先存内部延迟 Topic，到期由定时任务转投真实 Topic | 只能选档位，不能任意时间                                 |
| RocketMQ 5.x | 按毫秒时间戳投递（默认粒度 1000ms，最大 24h）                              | 精度受调度和积压影响；别同一时刻灌大量同时间消息                     |
| RabbitMQ     | TTL + DLX：给消息/队列设 TTL，过期死信到目标队列                           | 单消息 TTL 有**队头阻塞**坑（见下）；或用 delayed message 插件 |
| Kafka        | 没有原生延迟，外部调度系统（DB 扫表、时间轮）到期再发                              | 自建要管到期判断、恢复、可靠转发                             |

**RabbitMQ 队头阻塞**：队列前面的消息 TTL 没到，后面短 TTL 的消息不会被移除，必须等队头过期才一起死信，导致大量 " 该到期的没到期 "。固定档位就按档位拆多个等待队列；TTL 本质是过期策略，不是精确定时器。

**订单超时关闭的正确姿势**（高频场景题）：

1. 延迟消息只是**触发器**，消费者收到后去查订单当前状态，用条件更新 `UPDATE … WHERE status='待支付' AND 过期` 关单，已支付/已关闭就跳过。别在消费逻辑里无脑关。
2. 用户刚付款和关单消息并发：靠数据库原子状态迁移定胜负。支付晚了、订单已关，就走退款补偿流程。
3. 消息可能重复或晚到，幂等靠状态机；要取消任务就更新业务状态让旧消息失效，别指望从 Broker 精确撤回一条已发消息。
4. 兜底加一个 DB 到期扫描任务，别把关单这条业务命脉全押在一条延迟消息上。

## 18. 同组多台机器只有一个在消费？订单库存怎么用 MQ 保证最终一致？

### 只有一台在消费的排查（线上真题）

先分清 " 只有一台分到分区 " 还是 " 多台有分区但只有一台出活 "：

* **没分到**：分区数 < 实例数（副本数不增加消费并行度）；其他实例没正常入组（进程、实际 `group.id`、鉴权、订阅）；持续掉组（心跳、max.poll.interval 超时反复 Rebalance）；配置问题（误用同一个 `group.instance.id`、订阅不一致、`assign()` 手工指定）。
* **分到但没出活**：Key 倾斜全在一个分区；其他分区已追平或新组从末尾开始没消息；消息被过滤/幂等拦截/反序列化异常/业务线程阻塞；`read_committed` 被 LSO 卡住。

排查顺序：先看消费组成员和分区归属，再按分区对比 Log End Offset、已提交位点、Lag，最后看处理日志和业务落库。只有一台日志少不等于它没在跑。

[牛客 / 阿里一面 / 原帖第 39 题 / 团队未注明](https://www.nowcoder.com/feed/main/detail/6b1e1f5809134975a7febbe76b756f5e)。

### 订单 + 库存的最终一致闭环

前提：允许异步确认订单，但不能出现 " 订单已确认却没库存 " 或 " 订单已取消库存却一直占着 "。

1. 订单本地事务写 " 待库存确认 " 状态 + Outbox 事件，提交后可靠发出库存预占请求（事务消息同理，回查结果落库）。
2. 库存侧按稳定业务操作 ID 幂等，一个事务里条件预占（`WHERE stock >= n`）、记录成功或拒绝结果 + 结果 Outbox。**库存不足也是要可靠回传的业务结果**，不是异常。
3. 订单消费结果：成功就把 " 待确认 " 推进成 " 已确认 "；拒绝就取消。结果去重和订单更新放同一个事务。
4. 超时没结果：查询或补偿；决定取消就发释放请求，释放按原预占身份扣（不能无条件加库存），还要处理 " 释放先到、预占后到 " 的乱序，库存侧记一笔 " 该操作已取消 " 挡住迟到预占，或用业务版本号。

对账兜底：订单状态、库存预占记录、Outbox/Inbox、异常待办定期核对；受理量、完成率、延迟、补偿失败配监控。递增序号断号只能提示异常（乱序、过滤都会断号，尾部全丢甚至不报），真正的漏执行靠持久事件记录 + 终态对账发现。

最后一句话总结：MQ 给的是可靠投递和最终一致的**机制**，故障要能恢复、失败要能补偿、长期卡住的状态要有人处理，它不会自动回滚上游，也不能让库存不足的下游 " 必然成功 "。

[牛客 / 阿里一面 / 原帖第 30 至 32、38 题 / 团队未注明](https://www.nowcoder.com/feed/main/detail/6b1e1f5809134975a7febbe76b756f5e)。
