← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L19 - Kafka核心原理

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、Kafka架构


┌──────────────────────────────────────────────────────────┐
│                   Kafka 集群架构                           │
│                                                           │
│  ┌──────────┐     ┌───────────────────────────────┐      │
│  │ Producer  │     │      Kafka Cluster             │      │
│  │           │     │                                 │      │
│  │ send()    │────→│  Topic: order-events            │      │
│  │           │     │                                 │      │
│  └──────────┘     │  Partition 0  Partition 1  P2   │      │
│                    │  ┌────────┐  ┌────────┐  ┌──┐  │      │
│                    │  │Leader  │  │Leader  │  │L │  │      │
│                    │  │Broker1 │  │Broker2 │  │B3│  │      │
│                    │  ├────────┤  ├────────┤  ├──┤  │      │
│                    │  │Follower│  │Follower│  │F │  │      │
│                    │  │Broker2 │  │Broker3 │  │B1│  │      │
│                    │  ├────────┤  ├────────┤  ├──┤  │      │
│                    │  │Follower│  │Follower│  │F │  │      │
│                    │  │Broker3 │  │Broker1 │  │B2│  │      │
│                    │  └────────┘  └────────┘  └──┘  │      │
│                    └───────────────────────────────┘      │
│                                                           │
│  ┌──────────────┐                                        │
│  │ Consumer     │  Consumer Group: order-service          │
│  │ Group        │  Consumer0 → Partition0                  │
│  │              │  Consumer1 → Partition1                  │
│  │              │  Consumer2 → Partition2                  │
│  └──────────────┘  (一个Partition只能被Group中一个消费者消费) │
│                                                           │
│  ┌──────────────┐                                        │
│  │ KRaft        │  Kafka 3.x 不再依赖ZooKeeper            │
│  │ (Controller) │  · Controller选举                       │
│  │              │  · Partition Leader选举                  │
│  │              │  · 集群元数据管理                        │
│  └──────────────┘                                        │
└──────────────────────────────────────────────────────────┘

核心概念:


Broker:     Kafka服务节点,一个Kafka实例
Topic:      消息主题,逻辑分类(如order-events)
Partition:  Topic的物理分片,有序、不可变日志
Replica:    Partition的副本,Leader+ Followers(ISR)
Consumer Group: 消费者组,组内消费者分担消费Partition
Offset:     消息在Partition中的偏移量(序号)
ISR:        In-Sync Replicas,与Leader同步的副本集合

二、消息存储机制


Partition物理存储结构:
┌──────────────────────────────────────────────────┐
│ /kafka-logs/order-events-0/                      │
│                                                  │
│ 00000000000000000000.log    ← 消息数据文件        │
│ 00000000000000000000.index  ← 偏移量索引          │
│ 00000000000000000000.timeindex ← 时间戳索引       │
│                                                  │
│ 00000000000005367851.log    ← 第二个segment       │
│ 00000000000005367851.index                       │
│ 00000000000005367851.timeindex                   │
│                                                  │
│ ... 更多segment                                   │
└──────────────────────────────────────────────────┘

Segment机制:
- Partition被切分为多个Segment(默认1GB)
- 每个Segment = .log(数据) + .index(偏移量索引) + .timeindex(时间索引)
- .index: 稀疏索引,每隔4KB建一条索引
  通过二分查找快速定位Offset对应的物理位置

查找消息流程(如查找offset=368776):
1. 二分查找确定在哪个Segment文件
2. 在.index中二分查找 ≤ 368776 的最近索引项
3. 从该索引项的物理位置开始顺序扫描.log
4. 找到目标消息

顺序写 + 稀疏索引 → 写入和读取都高效

三、零拷贝(Zero-Copy)


传统数据传输(4次拷贝 + 4次上下文切换):
┌────────┐   ①DMA   ┌──────────┐  ②CPU   ┌──────────┐
│  磁盘   │ ───────→ │ 内核缓冲区 │ ──────→ │ 用户缓冲区 │
│        │          │(PageCache)│         │(App)     │
└────────┘          └──────────┘         └──────────┘
                                              │  ③CPU
                                              ▼
┌────────┐   ④DMA   ┌──────────┐  ③CPU   ┌──────────┐
│ 网卡   │ ←─────── │ Socket缓冲│ ←────── │ 用户缓冲区 │
│        │          │          │         │          │
└────────┘          └──────────┘         └──────────┘

零拷贝(sendfile, 2次拷贝 + 2次上下文切换):
┌────────┐   ①DMA   ┌──────────┐
│  磁盘   │ ───────→ │ 内核缓冲区 │
│        │          │(PageCache)│
└────────┘          └──────┬───┘
                           │  ②DMA (带scatter/gather)
                           ▼
                    ┌──────────┐   ②DMA   ┌────────┐
                    │ Socket缓冲│ ────────→│  网卡   │
                    └──────────┘          └────────┘

Kafka为什么快:
1. 顺序写: 追加到日志文件末尾,无需随机寻道
2. 零拷贝: sendfile系统调用,数据不经过用户空间
3. PageCache: 利用OS页缓存,热数据在内存
4. 批量压缩: 消息批量发送,减少网络开销
5. 分区并行: Topic多Partition,并行读写

四、消费者Rebalance


触发条件:
- 消费者加入/离开Consumer Group
- 订阅的Topic Partition数变化
- 消费者心跳超时(session.timeout.ms)

Rebalance过程:
┌──────────────────────────────────────────────────┐
│ 1. Coordinator(组协调者)检测到需要Rebalance        │
│ 2. 消费者发送JoinGroup请求                        │
│ 3. Leader消费者制定分配策略                        │
│    - RangeAssignor: 按范围分配                     │
│    - RoundRobinAssignor: 轮询分配                  │
│    - StickyAssignor: 尽量保持上次分配(推荐)        │
│ 4. 发送SyncGroup给所有消费者                       │
│ 5. 消费者按新分配消费                              │
└──────────────────────────────────────────────────┘

Rebalance的问题:
- 消费暂停(STW): Rebalance期间所有消费者停止消费
- 重复消费: Rebalance前已消费但未提交offset
- 解决:
  · session.timeout.ms适当调大(如25s)
  · heartbeat.interval.ms适当调小(如8s)
  · max.poll.interval.ms根据业务调整
  · 用StickyAssignor减少Partition迁移

五、ack机制


Producer确认机制:
┌────────────────────────────────────────────────────────┐
│ acks=0:                                                │
│   Producer不等确认,发完就继续                          │
│   → 最高性能,可能丢消息                                │
│   → 适用: 日志采集(丢几条无所谓)                        │
│                                                        │
│ acks=1:                                                │
│   等Leader写入成功就确认                                │
│   → Leader宕机且Follower未同步 → 可能丢                │
│   → 适用: 允许少量丢失的场景                            │
│                                                        │
│ acks=all(或-1):                                        │
│   等Leader + 所有ISR副本都写入成功才确认                │
│   → 最安全,不丢消息(前提:min.insync.replicas>=2)       │
│   → 适用: 业务消息(订单/支付)                           │
└────────────────────────────────────────────────────────┘

六、三种MQ对比

维度KafkaRocketMQRabbitMQ
开发语言Scala+JavaJavaErlang
单机吞吐10万+ TPS10万+ TPS万级 TPS
消息延迟ms级ms级us级
可靠性高(配好不丢)高(同步刷盘)高(镜像队列)
顺序消息单Partition有序单Queue有序单Queue有序
事务消息支持(Exactly Once)支持(半消息+回查,最佳)不支持
延迟消息不支持支持(18个级别)支持TTL+死信
消息回溯支持按offset/time支持按time不支持
消息过滤不支持服务端Tag/SQL92不支持服务端
适用场景大数据/日志/流处理电商/金融/事务消息中小型/低延迟
社区生态极活跃(Confluent)活跃(阿里)成熟稳定

选型决策树:


消息量级?
├── 日均亿级+ → Kafka(大数据场景)
├── 日均千万级 → RocketMQ(业务场景,需事务消息)
└── 日均百万以下
    ├── 需要us级延迟 → RabbitMQ
    └── 需要事务消息 → RocketMQ

七、面试高频四大问题

7.1 消息丢失(三环节防丢失)


Producer → Broker → Consumer

① Producer端:
   acks=all + retries=3 + enable.idempotence=true

② Broker端:
   replication.factor>=3 (3个副本)
   min.insync.replicas>=2 (至少2个ISR)
   unclean.leader.election.enable=false (禁止非ISR成为Leader)

③ Consumer端:
   enable.auto.commit=false (关闭自动提交)
   处理完业务再手动commit offset

7.2 消息顺序性


方案: 相同Key的消息发到同一Partition → 单Partition内FIFO

Producer:
  producer.send(new ProducerRecord("topic", orderId, value));
  // key相同 → hash到同一Partition

Consumer:
  一个Partition只被Consumer Group中一个消费者消费
  → 保证分区内有序

注意: 只能保证单Partition内有序,不是全局有序
      全局有序只能用1个Partition(吞吐低,不推荐)

7.3 消息幂等


为什么重复不可避免: Producer重试/Consumer ACK失败/网络抖动

幂等方案:
┌──────────────┬────────────────────┬─────────┐
│ 方案          │ 实现               │ 性能     │
├──────────────┼────────────────────┼─────────┤
│ Redis SETNX  │ SETNX msgId 1 EX  │ 高       │
│ 数据库唯一索引│ INSERT IGNORE      │ 中       │
│ 状态机        │ UPDATE WHERE status│ 高       │
│ 去重表        │ INSERT去重表       │ 中       │
└──────────────┴────────────────────┴─────────┘

推荐: Redis SETNX(快速去重) + 状态机(数据库级保证)
双重保障,即使Redis过期也能通过状态机拦截

7.4 消息堆积


排查:
1. kafka-consumer-groups --describe → 查LAG列
2. 分析原因: 消费者报错?消费逻辑慢?消费者数不够?

解决:
┌──────────────────┬──────────────────────────────────────┐
│ 方案              │ 操作                                  │
├──────────────────┼──────────────────────────────────────┤
│ 增加消费者        │ 消费者数 < Partition数时直接扩容       │
│ 批量消费          │ max.poll.records=500                  │
│ 转发新Topic       │ 新建Topic(更多Partition),转发消费     │
│ 跳过非关键消息    │ 设置消费位点跳过过期消息               │
└──────────────────┴──────────────────────────────────────┘

八、企业级Kafka配置


@Configuration
public class KafkaProducerConfig {
    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

        // 可靠性配置
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.RETRIES_CONFIG, 3);
        props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);

        // 性能配置
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);     // 16KB
        props.put(ProducerConfig.LINGER_MS_CONFIG, 10);         // 10ms凑批
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432); // 32MB

        return new DefaultKafkaProducerFactory<>(props);
    }
}

面试话术: "Kafka架构核心是Topic→Partition→Replica。Partition是不可变日志,通过Segment分段+稀疏索引实现高效存储。Kafka快是因为顺序写磁盘+零拷贝(sendfile)+PageCache。生产者ack=all+ISR>=2保证不丢消息。消费者用手动提交offset+幂等处理(SETNX+状态机)保证不重复消费。顺序性通过相同Key发同一Partition保证。选型上大数据用Kafka,业务消息用RocketMQ(事务消息),中小项目用RabbitMQ。"

面试速记卡(考前30秒速看)

练习题(自测)

1. Kafka的Partition和Consumer Group是什么关系?如果一个Topic有6个Partition,Consumer Group有3个消费者,怎么分配?如果消费者增加到8个呢?

2. 零拷贝(sendfile)相比传统传输减少了哪些步骤?为什么能提升性能?

3. acks=all一定能保证不丢消息吗?在什么配置下才能保证?

4. 如果Kafka消费者消费速度跟不上生产速度,导致消息堆积,你会有哪些排查步骤和解决方案?

5. Kafka和RocketMQ各自的事务消息实现机制有什么区别?

学习资料