面试题集锦: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)。任何一个环节出问题都能追溯。
三层防护
配置清单
# ===== 生产端 =====
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 SETNX | SETNX 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 流程
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 个副本上)。不重的关键:幂等生产者 + 消费者去重。
选主过程
丢数据场景 & 防护
丢数据场景:
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(复杂事件处理)识别攻击序列。
架构
检测的异常模式
| 模式 | 描述 | CEP 规则 |
|---|---|---|
| 盗号提现 | 新设备→改密码→小额→大额提现 | A followedBy B followedBy C within 5min |
| 刷量/撸毛 | 同一 IP 大量注册→领券→下单 | count(A) > 100 within 10min |
| 洗钱 | 分散转入→集中转出 | sum(amount) > 100k within 1h |
| 市场操纵 | 频繁自成交/wash trading | A 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
积压 = 生产速度 > 消费速度。应对梯队:临时扩容消费者(最快)→ 增加分区数(治本)→ 降级/跳过非关键消息(保核心)→ 死信队列兜底。
积压处理决策树
紧急措施
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 选型矩阵
| Kafka | RocketMQ | RabbitMQ | |
|---|---|---|---|
| 吞吐量 | ⭐⭐⭐⭐⭐(百万级 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 流程
避免重复
// 在 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(不能丢,延迟消息做告警收敛)。
选型
| 数据类型 | 选型 | 原因 |
|---|---|---|
| Metrics | Kafka | 百万级 TPS,少量丢失不影响趋势 |
| Traces | Kafka | 海量 Span,采样后仍很大 |
| Logs | Kafka | 日志量大,吞吐优先 |
| 告警 | 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 事务消息流程
对比
| RocketMQ 事务消息 | Kafka Transactions | |
|---|---|---|
| 模式 | 先发 prepare → 本地事务 → commit | beginTxn → 写多分区 → 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-userQ25: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 题)