面试题集锦:Kafka 与 RocketMQ

通识对照:Kafka、RabbitMQ 与 RocketMQ:日志流 vs 任务队列

面试题集锦:Kafka 与 RocketMQ

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:18 题
你的优势:D1-D3 + D6 全 done,这一 Batch 聚焦故障场景 + 交易特化 + 选型对比


Q1:Kafka 消息不丢的完整方案

TL;DR

生产端 acks=all + retries + 幂等 → Broker 副本≥3 + ISR≥2 + 禁止脏选举 → 消费端 手动提交 + 处理完再 commit。三层防护,缺一不可。

类比

📦 快递不丢三件套:寄件人留底单 + 拍照(生产 ACK)→ 中转站至少 2 人确认收到(Broker 副本)→ 收件人亲自签收(手动 commit)。任何一个环节出问题都能追溯。

三层防护

interview kafka rocketmq qa · 图 1
interview kafka rocketmq qa · 图 1 · 点击查看 SVG 原图

配置清单

# ===== 生产端 =====
acks=all                        # 所有 ISR 副本确认才返回成功
retries=3                       # 失败重试 3 次
enable.idempotence=true         # 幂等生产者(防止重试导致重复)
max.in.flight.requests.per.connection=5  # 幂等模式下可设 5
compression.type=lz4            # 压缩

# ===== Broker =====
default.replication.factor=3    # 每个 topic 默认 3 副本
min.insync.replicas=2           # 至少 2 个 ISR 副本确认才写入
unclean.leader.election.enable=false  # 禁止脏选举(ISR 外副本不能选主)

# ===== 消费端 =====
enable.auto.commit=false        # 禁用自动提交
auto.offset.reset=earliest      # 新 group 从最早开始
max.poll.records=500            # 每次最多拉 500 条

为什么 acks=all 还不能 100% 不丢?

极端场景:min.insync.replicas=2,副本数=3
→ ISR={副本1, 副本2},副本3 掉队了
→ 写入 → 副本1 确认,副本2 还没确认 → 副本1 宕机!
→ 但副本2 没有这份数据(还没确认)→ 数据丢失!

修正:min.insync.replicas=2, replication.factor=3
→ 写入需 2 个副本确认 → 至少 2 个副本有这份数据
→ 1 个副本宕机,还有 1 个 → 数据安全

记忆锚

"ack=all → ISR≥2 → 手动 commit,三层各司其职"


Q2:Kafka 消息幂等与去重

TL;DR

幂等 = 同一条消息消费多次,结果与消费一次相同。三层去重:生产者幂等(PID+SeqNum 去重)→ Broker 去重(事务消息)→ 消费者去重(去重表/业务唯一键/Redis)。

类比

🆔 身份证号码:每个人一个唯一 ID,银行办业务时查"这个人今天来过了吗"(去重表)。来过就不给办了(幂等)。

消费者去重三方案

方案实现可靠性适用
去重表(DB 唯一键)INSERT INTO consumed (msg_id) VALUES (?)⭐⭐⭐⭐⭐金融核心
Redis SETNXSETNX msg:{id} 1 EX 86400⭐⭐⭐(可能丢失)普通业务
业务状态机UPDATE ... WHERE status='PENDING'⭐⭐⭐⭐有状态的业务

去重表设计

CREATE TABLE idempotent_consumed (
    msg_id VARCHAR(128) PRIMARY KEY,  -- 消息唯一 ID
    topic VARCHAR(64),
    consumer_group VARCHAR(64),
    consumed_at DATETIME,
    INDEX idx_consumed_at (consumed_at)  -- 定期清理
);
 
-- 消费时:INSERT + 业务操作 = 同一个事务
BEGIN;
  INSERT INTO idempotent_consumed VALUES (?, ?, ?, NOW());  -- 重复报错 → 回滚
  -- 业务操作...
COMMIT;

Redis SETNX 为什么不可靠?

问题 1:过期后 key 删除 → 同一消息可以再次消费
问题 2:主从切换 → SETNX 在主节点成功,还没同步到从,主挂了 → 从提升 → 数据丢失

结论:Redis SETNX 只能做"性能优化层"(快速判断大概率重复),
      不能做最终兜底(必须 DB 唯一键兜底)

记忆锚

"DB 去重表是兜底,Redis SETNX 是加速,业务状态机是天然幂等"


Q3:服务重启,如何避免 Kafka 消息丢失?

TL;DR

Graceful Shutdown = 暂停消费(consumer.pause)→ 处理完积压 → 手动提交 offset → 关闭 consumer。核心:不能在消息未处理完时就关闭 consumer。

类比

🍽️ 餐厅打烊:不能直接把客人赶走。正确做法:不再接新客(pause)→ 等当前客人吃完(处理积压)→ 结账(提交 offset)→ 关灯(close)。

Graceful Shutdown 流程

interview kafka rocketmq qa · 图 2
interview kafka rocketmq qa · 图 2 · 点击查看 SVG 原图

Spring Kafka 配置

spring:
  kafka:
    consumer:
      enable-auto-commit: false
    listener:
      ack-mode: manual_immediate
  lifecycle:
    timeout-per-shutdown-phase: 30s  # 给 30 秒优雅关闭
 
server:
  shutdown: graceful  # Spring Boot 2.3+

Go 实现

func main() {
    // 监听退出信号
    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
 
    go func() {
        <-sigCh
        log.Println("Shutting down gracefully...")
        
        // 1. 标记不健康(LB 停止发流量)
        healthCheck.SetNotReady()
        
        // 2. 停止消费新消息
        consumer.Pause()
        
        // 3. 等待积压处理完
        time.Sleep(5 * time.Second)
        wg.Wait()  // 等待所有在处理的消息完成
        
        // 4. 提交 offset
        consumer.CommitSync()
        
        // 5. 关闭
        consumer.Close()
        os.Exit(0)
    }()
}

记忆锚

"pause→处理完→commit→close,30s 优雅退出窗口"


Q4:Kafka Rebalance 期间如何避免消息丢失/重复?

TL;DR

Rebalance 会导致分区重新分配 → 原消费者未提交的 offset 丢失 → 新消费者从上次提交位置开始 → 可能重复消费。解决:CooperativeStickyAssignor(渐进式,不全停)+ 手动提交(处理完一条提交一条)。

Rebalance 触发条件

1. Consumer Group 成员变化(新加入/离开)
2. Topic 分区数变化
3. max.poll.interval.ms 超时(消费者处理太慢被踢出)
4. session.timeout.ms 超时(心跳超时被踢出)

CooperativeStickyAssignor

Eager 协议(旧):
  所有消费者停止 → 重新分配 → 恢复消费
  → 全部暂停(stop-the-world)→ 延迟高

Cooperative 协议(新):
  只重新分配变化的那些分区 → 其他分区继续消费
  → 部分暂停 → 延迟低

配置

# 使用 CooperativeStickyAssignor
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor

# 加大超时,避免误踢
max.poll.interval.ms=600000       # 10 分钟(默认 5 分钟)
session.timeout.ms=45000          # 45 秒

# 静态成员(不参与 Rebalance!)
group.instance.id=risk-consumer-1 # 固定实例 ID → 重启也不触发 Rebalance

记忆锚

"CooperativeStickyAssignor 渐进式 + 静态成员免 Rebalance + 手动提交防重复"


Q5:Kafka Rebalance 选主期间如何保证不丢不重?

TL;DR

分区选主 = Controller 从 ISR 中选一个新 Leader。不丢的关键:ISR≥2 + acks=all(数据至少在 2 个副本上)。不重的关键:幂等生产者 + 消费者去重。

选主过程

interview kafka rocketmq qa · 图 3
interview kafka rocketmq qa · 图 3 · 点击查看 SVG 原图

丢数据场景 & 防护

丢数据场景:
  Leader 有 msg-1~msg-100 → ISR 中的 Follower 只有 msg-1~msg-95
  → Leader 宕机 → Follower 提升 → msg-96~100 丢失

防护:
  1. unclean.leader.election=false(宁可不可用也不丢)
  2. acks=all + min.insync.replicas=2(数据至少 2 个副本)
  3. 监控 ISR 数量(ISR 掉到 1 就告警)

重复消费场景 & 防护

重复消费场景:
  消费者消费了 msg-100,但还没提交 offset → Rebalance
  → 新消费者从上次提交的 offset=95 开始 → msg-96~100 重复消费

防护:
  1. 手动提交 offset(处理完立即提交)
  2. 消费者去重表(业务唯一键防重)
  3. 消费逻辑幂等(加状态机判断)

记忆锚

"ISR 全挂了宁可不可用(unclean=false),也不丢数据"


Q6:Kafka 顺序消息如何保证?

TL;DR

顺序消息 = 同一 key 发送到同一分区 + 分区内单线程串行消费 + max.in.flight.requests.per.connection=1(禁止生产端重排序)。

类比

🚂 铁轨上的火车:所有去北京(同 key)的货物装同一列火车(同分区),按装车顺序到达(分区内有序)。但如果用多列火车(多分区),A 列车先装后到,B 列车后装先到——顺序就乱了。

三要素

1. 生产端:指定 key → 同一 key 的所有消息进入同一分区
   producer.send(new ProducerRecord<>(topic, userId, message));
   // userId 作为 key → 同一用户的所有消息有序

2. 生产端:禁止重排序
   max.in.flight.requests.per.connection=1  ← 必须设为 1!
   默认=5 → 后发的消息可能先到 → 顺序乱

3. 消费端:单线程串行
   一个分区只能被同组的一个消费者消费
   → 天然串行,不需额外处理

你能接受的代价

代价 1:性能下降(max.in.flight=1,吞吐降到 1/5)
代价 2:分区不能动态扩容(扩容 → key 的 hash 值会变 → 同 key 消息可能换分区)
代价 3:Rebalance 导致的短暂乱序(用幂等兜底,少量重复不影响业务)

记忆锚

"同 key→同分区→单线程消费→in.flight=1,顺序是拿性能换的"


Q7:从 Kafka 消费行为日志做实时风控分析

TL;DR

消费链 = Kafka(按 user_id 分区)→ Flink/Go 消费者 → 滑动窗口聚合(1min/5min 窗口)→ 规则匹配(异常模式识别)→ 触发风控动作。核心:CEP(复杂事件处理)识别攻击序列。

架构

interview kafka rocketmq qa · 图 4
interview kafka rocketmq qa · 图 4 · 点击查看 SVG 原图

检测的异常模式

模式描述CEP 规则
盗号提现新设备→改密码→小额→大额提现A followedBy B followedBy C within 5min
刷量/撸毛同一 IP 大量注册→领券→下单count(A) > 100 within 10min
洗钱分散转入→集中转出sum(amount) > 100k within 1h
市场操纵频繁自成交/wash tradingA followedBy B where A.price≈B.price

窗口聚合

// Flink 滑动窗口:1 分钟内交易次数和金额
DataStream<TradeEvent> trades = env.addSource(kafkaSource);
 
trades
    .keyBy(TradeEvent::getUserId)
    .window(SlidingEventTimeWindows.of(Time.minutes(1), Time.seconds(10)))
    .aggregate(new RiskAggregateFunction())
    .filter(result -> result.getTradeCount() > 50)  // 1 分钟 > 50 笔 → 可疑
    .addSink(riskAlertSink);

记忆锚

"按 userId 分区→滑动窗口聚合→CEP 序列检测→规则匹配→触发动作"


Q8:Kafka 消息积压应对方案

TL;DR

积压 = 生产速度 > 消费速度。应对梯队:临时扩容消费者(最快)→ 增加分区数(治本)→ 降级/跳过非关键消息(保核心)→ 死信队列兜底。

积压处理决策树

interview kafka rocketmq qa · 图 5
interview kafka rocketmq qa · 图 5 · 点击查看 SVG 原图

紧急措施

1. 临时加消费者:
   → kubectl scale deployment risk-consumer --replicas=20
   → 最多加到分区数(再多没意义,分不到分区)

2. 跳过非关键消息:
   → 如果消息有优先级,低优先级的跳过
   → 消费时 filter:只处理金额 > 阈值的交易

3. 历史积压直接跳过:
   → consumer.seekToEnd() 丢弃全部积压
   → 前提:积压的是非核心消息(如日志、监控)
   → ⚠️ 交易消息绝对不能用这招!

4. 转死信:
   → 消费失败的消息 → 重试 3 次 → 入死信队列
   → 避免一条坏消息阻塞整个分区

避免积压的预防措施

1. 监控 consumer_lag(lag > 10 万 → 告警)
2. 分区数 = 峰值 QPS × 处理耗时 / 1000 × 2(冗余系数)
3. 消费者数 ≥ 分区数(充分利用并行度)
4. 定时压测(知道单分区消费能力上限)

记忆锚

"扩容→加分区→跳过→死信,积压期间监控 lag 不丢数据"


Q9:Kafka vs RocketMQ vs RabbitMQ 选型矩阵

KafkaRocketMQRabbitMQ
吞吐量⭐⭐⭐⭐⭐(百万级 TPS)⭐⭐⭐⭐(十万级 TPS)⭐⭐⭐(万级 TPS)
延迟ms 级ms 级μs 级
消息顺序分区内有序队列内严格有序队列内有序
事务消息✅(Kafka Transactions)✅ 原生支持❌
延时消息❌(需外部实现)✅ 18 个延迟级别✅(DLX+TLL 变通)
运维复杂度⭐⭐⭐(依赖 ZooKeeper)⭐⭐⭐
适用场景大数据流/日志/埋点交易/订单/金融低延迟/复杂路由

选型决策

大数据流 / 日志采集 / 实时计算 → Kafka(吞吐为王)
交易核心链路 / 事务消息 / 延迟消息 → RocketMQ(功能全面)
复杂路由 / 低延迟点对点 / 小规模 → RabbitMQ

记忆锚

"Kafka 求吞吐,RocketMQ 求功能全,RabbitMQ 求灵活"


Q10:Kafka 事务消息(Exactly-Once)

TL;DR

Kafka Exactly-Once = 幂等生产者(PID + SeqNum 去重)+ 事务(跨分区原子写入)+ 消费者隔离级别(read_committed)。代价:性能下降约 30%。

配置

# 生产端:开启幂等 + 事务
enable.idempotence=true
transactional.id=tx-risk-engine-1  # 事务 ID,重启后不变

# 消费端:只读已提交的消息
isolation.level=read_committed

事务语义

producer.initTransactions();
try {
    producer.beginTransaction();
    producer.send(record1);  // 风控事件
    producer.send(record2);  // 审计日志
    producer.sendOffsetsToTransaction(consumerOffsets);  // offset 也在事务内
    producer.commitTransaction();
} catch (Exception e) {
    producer.abortTransaction();
}
// → record1 和 record2 要么都可见,要么都不可见(原子!)

代价

1. 性能下降 30%(事务协调开销)
2. 需要 Broker 端支持事务日志
3. 跨会话的事务 ID 不能冲突

→ 适合:风控决策 + 审计日志必须原子落盘
→ 不适合:高频日志/监控数据(吞吐优先)

记忆锚

"幂等+事务+read_committed = Exactly-Once,代价 30% 性能"


Q11:Kafka 高吞吐量原理

TL;DR

Kafka 高吞吐四大支柱:顺序写入(磁盘顺序写 600MB/s ≈ 内存随机写)→ 零拷贝(sendfile 系统调用,数据不经过用户态)→ PageCache(OS 缓存热数据)→ 批量+压缩(Producer 攒一批再发)。

类比

📝 抄书 vs 打印:随机写 = 手抄(慢)。顺序写 = 打印机(极快)。Kafka 把消息当"连续的一卷纸",用打印机(顺序 IO)吐出来,而不是一页页手抄。

四大支柱

支柱原理效果
顺序 IO日志段文件 append only磁盘写 600MB/s
零拷贝sendfile() 直接从 PageCache 到网卡减少 2 次 CPU 拷贝
PageCache最新写入的数据在 OS 缓存中读不落盘
批量压缩Producer 攒一批 → 压缩 → 一批发送减少网络 + 磁盘

零拷贝流程

传统(4 次拷贝):
  磁盘 → 内核缓冲区 → 用户缓冲区 → Socket 缓冲区 → 网卡

Kafka 零拷贝(2 次拷贝):
  磁盘 → PageCache(内核) → 网卡(sendfile 直接 DMA 传输)

记忆锚

"顺序 IO + 零拷贝 + PageCache + 批量发送 = 百万 TPS"


Q12:Kafka vs RocketMQ —— 有序性 / 吞吐量 / 可靠性对比

TL;DR(口述版)

"有序性:RocketMQ 更好。它的队列模型天然保证全局顺序(一个队列一个消费者),
Kafka 只能保证分区内有序。

吞吐量:Kafka 更强。百万级 TPS,靠顺序 IO + 零拷贝。RocketMQ 十万级。

可靠性:两者都很好,但实现路径不同:
  Kafka:ISR 机制 + acks=all + 副本同步
  RocketMQ:同步刷盘 + 主从同步 + DLedger(Raft)

行情场景选择:
  如果有序性要求高(如订单簿增量必须有序)→ RocketMQ
  如果吞吐量要求高(如百万 tick 每秒)→ Kafka
  大部分交易所两者都用:Kafka 做数据管道,RocketMQ 做交易核心"

记忆锚

"RocketMQ 有序强,Kafka 吞吐强,各自适用不同场景"


Q13:RocketMQ 消息顺序性 + 乱序后果

TL;DR

RocketMQ 顺序消息 = 消息发送到同一 MessageQueue + 消费者对同一队列加锁串行消费。交易场景乱序 = 先入金后出金的顺序颠倒 → 余额可能在入金前变成负数 → 出金被拒绝。

乱序的严重后果

正常顺序:入金 +100 → 扣款 -50 → 余额 50
乱序:   扣款 -50 → 入金 +100 → 余额 50(结果对但中间可能报错"余额不足")

交易系统:乱序可能导致
  1. 用户余额短暂为负 → 触发风控冻结(误杀)
  2. 订单状态流转错乱(先成交后创建?→ 数据异常)
  3. 对账时发现"钱对不上"(顺序不同导致中间状态不一致)

记忆锚

"先充后花,顺序一乱花不出去——交易乱序 = 用户被误杀"


Q14:全链路消息可靠传递

TL;DR

全链路 = 生产者可靠发送(acks=all + 本地消息表兜底)→ Broker 可靠存储(多副本 + ISR)→ 消费者可靠消费(手动提交 + 去重表)。核心:没有任何一个环节是"发后即忘"的。

全链路保障措施

生产者端:
  ✅ acks=all(等待 ISR 确认)
  ✅ 同步发送(get() 等结果)
  ✅ 本地消息表兜底(定时补偿发送失败的消息)
  ✅ 幂等(enable.idempotence)

Broker 端:
  ✅ 副本数 ≥ 3
  ✅ min.insync.replicas = 2
  ✅ unclean.leader.election.enable = false

消费者端:
  ✅ 手动提交 offset
  ✅ 去重表(DB 唯一键)
  ✅ 死信队列(重试 3 次失败 → 人工介入)
  ✅ 处理完成后才提交 offset

记忆锚

"生产者有兜底,Broker 有副本,消费者有去重——三重保障不丢不重"


Q15:消息队列解耦和削峰的应用场景

TL;DR(口述版,结合你的游民项目)

"在我们 某业务 的架构中,消息队列用于两个核心场景:

1. 解耦:用户行为日志采集
   前端埋点 → Kafka → Flink 实时分析 + Hive 离线分析
   如果没有 Kafka,前端需要直接调分析服务的 API → 
   分析服务挂了会影响前端 → 通过 Kafka 解耦,前端只管发,出问题也不影响用户体验。

2. 削峰:内容推荐计算
   早高峰 QPS 从 5K 涨到 15K → 推荐计算耗时 200ms →
   如果同步调用,用户等 200ms 才看到推荐 → 用 MQ 异步:
   请求进入 → 快速返回缓存 → 后台 MQ 触发推荐计算 → 更新缓存
   用户体验从 200ms 降到 5ms(直接读缓存返回)

记忆锚

"解耦 = 不直接调,削峰 = 不等同步——MQ 让慢操作异步化"


Q16:百万级消息积压处理

详见 Q8,此处强调交易所场景的差异:

交易所积压 = 资金相关消息积压 → 绝对不能跳过!

常规系统:seekToEnd → 丢弃积压,从最新开始
交易所:必须逐条处理!

方案:
  1. 紧急扩容消费者(临时开到分区数 × 2)
  2. 暂停非核心消费者,把 CPU/IO 资源让给核心消费者
  3. 如果积压的是非交易消息(如日志),把它们临时路由到另一个 topic
  4. 极限情况:降级——消费只做"关键字段提取 + 落库",不做复杂计算
  5. 事后补偿:积压清完后,跑离线任务补齐跳过的计算

记忆锚

"交易所积压不能跳,只能扩——加机器、降级计算、事后补偿"


Q17:Consumer Group Rebalance 详解 + 避免重复

TL;DR

Rebalance = GroupCoordinator 检测到成员变化 → 重新分配分区 → 各消费者收到 onPartitionsRevoked + onPartitionsAssigned。避免重复消费:处理完一条提交一条(同步提交)+ 去重表兜底。

Rebalance 流程

interview kafka rocketmq qa · 图 6
interview kafka rocketmq qa · 图 6 · 点击查看 SVG 原图

避免重复

// 在 onPartitionsRevoked 中提交当前 offset
@KafkaListener(topics = "risk-events")
public void consume(ConsumerRecord<String, String> record, Acknowledgment ack) {
    processRiskEvent(record);  // 处理 + 去重表写入 = 同一事务
    ack.acknowledge();         // 手动提交(同步!)
}

记忆锚

"Rebalance 不可避免,靠手动同步提交 + 去重表兜底"


Q18:Kafka / RocketMQ 在可观测性数据管道中的选型

TL;DR

可观测性数据管道 = Metrics 用 Kafka(高吞吐,容忍少量丢失)→ Traces 用 Kafka(海量 span,吞吐优先)→ Logs 用 Kafka(流式处理)→ 告警用 RocketMQ(不能丢,延迟消息做告警收敛)。

选型

数据类型选型原因
MetricsKafka百万级 TPS,少量丢失不影响趋势
TracesKafka海量 Span,采样后仍很大
LogsKafka日志量大,吞吐优先
告警RocketMQ不能丢 + 延迟消息做告警收敛
审计RocketMQ不能丢 + 顺序性

记忆锚

"量大选 Kafka,事大(告警/审计)选 RocketMQ"


B7 补充:MQ 深度追问(Q19-Q33)

以下来自 questions.md 一面弱项,按面试追问频率排列。


Q19:RocketMQ 原生事务消息 vs Kafka Transactions

TL;DR

RocketMQ 事务消息 = 半消息(prepare → 执行本地事务 → commit/rollback)→ Broker 定时回查。Kafka Transactions = 幂等生产者 + 事务协调器(跨分区原子写入)。RocketMQ 更适合"先发消息再做本地操作"的场景(如订单创建),Kafka 更适合"多分区原子写入"(如审计日志+风控事件)。

RocketMQ 事务消息流程

interview kafka rocketmq qa · 图 7
interview kafka rocketmq qa · 图 7 · 点击查看 SVG 原图

对比

RocketMQ 事务消息Kafka Transactions
模式先发 prepare → 本地事务 → commitbeginTxn → 写多分区 → commitTxn
回查✅ Broker 定时回调生产者确认❌ 依赖生产者主动 abort
适用异步解耦场景(订单→通知)流式原子写入(ETL/审计)
性能开销低(只多一次 prepare)中(事务协调器开销 ~30%)

记忆锚

"RocketMQ 先发后做事 + Broker 回查兜底。Kafka 多分区原子写 + 无回查"


Q20:Kafka 广播消息

TL;DR

Kafka 广播 = 每个消费者属于不同的 Consumer Group。同一 group 内一个分区只给一个消费者(负载均衡)。不同 group 之间独立消费同一 topic(广播)。核心:广播 = 多个 Consumer Group 订阅同一个 topic。

# 广播实现:3 个服务各自建独立 group
服务A: group.id=service-a-group  → 消费 topic:risk-events 全部
服务B: group.id=service-b-group  → 消费 topic:risk-events 全部
服务C: group.id=service-c-group  → 消费 topic:risk-events 全部
# 每个服务都能收到所有消息 = 广播!

记忆锚

"同 group 负载均衡,不同 group 独立消费=广播"


Q21:Kafka 延迟消息 & 优先级队列

TL;DR

Kafka 原生不支持延迟消息和优先级队列。延迟消息需要外部方案(时间轮 + 重新投递)。优先级队列天生与 Kafka 的顺序 IO + 分段日志冲突——Kafka 为吞吐牺牲了灵活性。需要这些特性 → 选 RocketMQ(原生支持 18 级延迟 + 优先级)。

RocketMQ 延迟消息

发送时设置 delayLevel(1~18,对应 1s~2h 的延迟时间)
→ Broker 收到后先存在延迟队列(SCHEDULE_TOPIC_XXXX)
→ 定时任务到期后 → 投递到目标 topic → 消费者正常消费

原理:内存时间轮(TimerWheel)+ 磁盘延迟队列
不增加额外存储开销(复用 commitlog)

为什么 Kafka 不做延迟消息?

Kafka 的日志段(Segment)只能 append,不能"插入中间"。
做延迟消息意味着消息写入后不能马上被消费 → 
要么:单独维护一个"延迟段"定时检查(性能差)
要么:改变整个日志模型(违背设计哲学)

RocketMQ 的 commitlog + consumeQueue 分离设计天然支持延迟。

记忆锚

"延迟/优先级→RocketMQ 原生支持。Kafka 为吞吐牺牲灵活性"


Q22:Kafka 自动提交 offset 机制 + 为什么手动提交

TL;DR

自动提交(enable.auto.commit=true)= consumer 在 auto.commit.interval.ms(默认 5s)定时提交当前 poll 到的最大 offset。致命问题:poll 到但还没处理完的消息 → 自动提交了 offset → consumer 挂了 → 消息永久丢失! 所以必须手动提交。

三种提交对比

方式配置行为丢消息
自动提交auto.commit=true每 5s 自动提交⚠️ 可能丢
手动异步提交commitAsync()不阻塞,不重试⚠️ 可能丢
手动同步提交commitSync()阻塞直到确认✅ 不丢

记忆锚

"自动提交 = 定时提交 poll 到的 offset,消息可能没处理完就标记已消费→危险"


Q23:Kafka 消息积压 + 磁盘报警 + 服务挂掉

TL;DR

消息积压倒逼磁盘 → Broker 磁盘打满 → ISR 掉线 → 服务不可用。应急三步:1. 扩容磁盘(最快,临时方案)→ 2. 增加消费者(治标)→ 3. 设置 retention 策略缩短(清历史数据,危险)。事后排查:为什么消费慢?单条处理慢还是分区数不够?

磁盘打满的灾难链

下游消费慢 → 分区积压 → 磁盘使用率 85%→90%→95% 
→ Broker 拒绝写入(watermark)→ 生产者报错 → 业务中断
→ 磁盘满 → Kafka 进程 OOM/退出

紧急处理:
1. kubectl edit pvc → 扩容磁盘(云上几分钟)
2. 紧急增加消费者实例(消费能力翻倍)
3. 限流生产端(保护 Broker)
4. 缩短 log.retention.hours(不得已,会丢数据)
5. 迁移部分 topic 到另一个集群(大手术)

记忆锚

"积压→磁盘→Broker 拒绝写入。先扩磁盘+加消费者→限流生产→长期扩分区"


Q24:Kafka Quota(配额控制)

TL;DR

Kafka Quota = 限制单个 client-id 或 user 的吞吐(bytes/sec)和请求速率。防止一个失控的生产者/消费者拖垮整个集群。生产环境必须开启。

# 限制 client-id=risk-producer 的吞吐
kafka-configs --alter --add-config 'producer_byte_rate=104857600' \
  --entity-type clients --entity-name risk-producer
# → 限制 100MB/s
 
# 限制 user 的请求速率
kafka-configs --alter --add-config 'request_percentage=50' \
  --entity-type users --entity-name risk-user

Q25:Kafka Broker 数量影响什么?

TL;DR

Broker 数量影响:可用性(≥3 个才有真正高可用)→ 吞吐量(更多 broker = 更多分区 = 更多并行度)→ 容灾(跨机架/跨 AZ 部署需要多 broker)。

3 broker → 副本数=3, ISR=2 → 单 broker 宕机不影响
4+ broker → 可跨 AZ 部署 → AZ 级容灾
2 broker → 不够(副本数=3 时分区无法分配到 3 个独立节点)
1 broker → 开发/测试用,生产自杀

Q26:Kafka 高吞吐原理 → 已在 Q11 覆盖,此处略。


Q27:IM 聊天场景 Kafka 架构

TL;DR

IM 消息 = 按 roomId 分区(同房间消息有序)→ 消费者轮询 push 到 WebSocket 网关 → 网关本地缓存最近 N 条。核心:消息不能丢、同房间有序、历史消息可回溯。

架构

用户A 发消息 → API Gateway → Kafka(topic: im-messages, key=roomId)
→ 推送消费者(每个分区一个)→ 推送给 roomId 对应的 WebSocket 网关
→ 网关 → 广播给房间内所有在线用户

历史消息:Kafka → Flink 清洗 → ES/HBase 归档 → 用户拉取

记忆锚

"按 roomId 分区保证房间内有序,消费端推 WebSocket,历史走 ES 归档"


Q28:死信队列深入

TL;DR

死信队列(DLQ)= 消费失败重试 N 次仍失败的消息 → 转入死信 topic,避免阻塞正常消息消费。核心价值:一条坏消息不会卡住整个分区。需配套:告警 + 人工处理界面 + 重放能力。

不是"解决消息丢失"

死信队列不解决丢失!它解决的是:
  ❌ 不是:消息丢了,我去死信队列找
  ✅ 而是:这条消息有问题导致消费一直失败,我先隔离它,让其他消息正常消费
  → 防止一条毒消息(poison pill)阻塞整个分区

记忆锚

"死信 = 隔离坏消息保好消息,不是丢了的消息能找回"


Q29:Kafka Exactly-Once → 已在 Q10 覆盖


Q30:Kafka 分区扩容 + Rebalance 的顺序性影响

TL;DR

分区扩容 → 同一 key 的消息可能被 rehash 到不同分区 → 顺序性丢失! 解决方案:永远不扩容(一开始就设足够多的分区)或者业务层接受短暂乱序(靠幂等兜底,只有少量重复不影响正确性)。

记忆锚

"分区数 = 不可变常量,生产环境一旦确定就永远不扩——这是顺序消息的前提代价"


Q31:RocketMQ 消息积压 + 磁盘报警应急

TL;DR

RocketMQ 积压与 Kafka 类似。额外能力:重置消费位点(跳过积压的历史消息,从最新开始消费)→临时增加队列读写权限(让积压队列暂停写入)。


Q32:消费者去重表 vs Redis SETNX — 深入

TL;DR

去重表 = 业务 DB 中建一个 consumed_msg 表,msg_id 做主键。消费时 INSERT INTO consumed_msg VALUES (msg_id) → 成功=第一次消费,唯一键冲突=重复消息直接跳过。Redis SETNX 只能加速判断,不能做最终兜底(会过期、主从切换丢失)。

记忆锚

"去重表主键是最终答案,Redis SETNX 是加速缓存——Redis 丢了不怕,DB 唯一键保底"


Q33:Kafka Consumer 并发 = 分区数?

TL;DR

对。1 个分区只能被同 group 的1 个消费者消费。多余消费者闲着。所以:消费者数 ≤ 分区数。想提高消费并行度 → 增加分区数。


总结

事务消息  → RocketMQ 半消息+回查,Kafka 事务协调器
广播      → 不同 Consumer Group 独立消费
延迟/优先级 → RocketMQ 原生支持,Kafka 需外部方案
自动提交  → 定时提交 poll 到的 offset,可能丢消息
磁盘积压  → 扩磁盘→加消费者→限流生产→缩短 retention
死信      → 隔离坏消息保好消费,不是丢了的消息能找回
去重      → DB 主键兜底,Redis SETNX 加速
顺序+扩容 → 分区数确定后不扩,否则重新 hash→乱序

下一篇:B12 存储深度(18 题)