┌──────────────────────────────────────────────────────────┐
│ 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. 找到目标消息
顺序写 + 稀疏索引 → 写入和读取都高效
传统数据传输(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,并行读写
触发条件:
- 消费者加入/离开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迁移
Producer确认机制:
┌────────────────────────────────────────────────────────┐
│ acks=0: │
│ Producer不等确认,发完就继续 │
│ → 最高性能,可能丢消息 │
│ → 适用: 日志采集(丢几条无所谓) │
│ │
│ acks=1: │
│ 等Leader写入成功就确认 │
│ → Leader宕机且Follower未同步 → 可能丢 │
│ → 适用: 允许少量丢失的场景 │
│ │
│ acks=all(或-1): │
│ 等Leader + 所有ISR副本都写入成功才确认 │
│ → 最安全,不丢消息(前提:min.insync.replicas>=2) │
│ → 适用: 业务消息(订单/支付) │
└────────────────────────────────────────────────────────┘
| 维度 | Kafka | RocketMQ | RabbitMQ |
|---|---|---|---|
| 开发语言 | Scala+Java | Java | Erlang |
| 单机吞吐 | 10万+ TPS | 10万+ TPS | 万级 TPS |
| 消息延迟 | ms级 | ms级 | us级 |
| 可靠性 | 高(配好不丢) | 高(同步刷盘) | 高(镜像队列) |
| 顺序消息 | 单Partition有序 | 单Queue有序 | 单Queue有序 |
| 事务消息 | 支持(Exactly Once) | 支持(半消息+回查,最佳) | 不支持 |
| 延迟消息 | 不支持 | 支持(18个级别) | 支持TTL+死信 |
| 消息回溯 | 支持按offset/time | 支持按time | 不支持 |
| 消息过滤 | 不支持服务端 | Tag/SQL92 | 不支持服务端 |
| 适用场景 | 大数据/日志/流处理 | 电商/金融/事务消息 | 中小型/低延迟 |
| 社区生态 | 极活跃(Confluent) | 活跃(阿里) | 成熟稳定 |
选型决策树:
消息量级?
├── 日均亿级+ → Kafka(大数据场景)
├── 日均千万级 → RocketMQ(业务场景,需事务消息)
└── 日均百万以下
├── 需要us级延迟 → RabbitMQ
└── 需要事务消息 → RocketMQ
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
方案: 相同Key的消息发到同一Partition → 单Partition内FIFO
Producer:
producer.send(new ProducerRecord("topic", orderId, value));
// key相同 → hash到同一Partition
Consumer:
一个Partition只被Consumer Group中一个消费者消费
→ 保证分区内有序
注意: 只能保证单Partition内有序,不是全局有序
全局有序只能用1个Partition(吞吐低,不推荐)
为什么重复不可避免: Producer重试/Consumer ACK失败/网络抖动
幂等方案:
┌──────────────┬────────────────────┬─────────┐
│ 方案 │ 实现 │ 性能 │
├──────────────┼────────────────────┼─────────┤
│ Redis SETNX │ SETNX msgId 1 EX │ 高 │
│ 数据库唯一索引│ INSERT IGNORE │ 中 │
│ 状态机 │ UPDATE WHERE status│ 高 │
│ 去重表 │ INSERT去重表 │ 中 │
└──────────────┴────────────────────┴─────────┘
推荐: Redis SETNX(快速去重) + 状态机(数据库级保证)
双重保障,即使Redis过期也能通过状态机拦截
排查:
1. kafka-consumer-groups --describe → 查LAG列
2. 分析原因: 消费者报错?消费逻辑慢?消费者数不够?
解决:
┌──────────────────┬──────────────────────────────────────┐
│ 方案 │ 操作 │
├──────────────────┼──────────────────────────────────────┤
│ 增加消费者 │ 消费者数 < Partition数时直接扩容 │
│ 批量消费 │ max.poll.records=500 │
│ 转发新Topic │ 新建Topic(更多Partition),转发消费 │
│ 跳过非关键消息 │ 设置消费位点跳过过期消息 │
└──────────────────┴──────────────────────────────────────┘
@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。"
1. Kafka的Partition和Consumer Group是什么关系?如果一个Topic有6个Partition,Consumer Group有3个消费者,怎么分配?如果消费者增加到8个呢?
2. 零拷贝(sendfile)相比传统传输减少了哪些步骤?为什么能提升性能?
3. acks=all一定能保证不丢消息吗?在什么配置下才能保证?
4. 如果Kafka消费者消费速度跟不上生产速度,导致消息堆积,你会有哪些排查步骤和解决方案?
5. Kafka和RocketMQ各自的事务消息实现机制有什么区别?