知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 04 - 消费者详解 > 导读:消费者的难点不在 `poll()`,而在处理完成与位移提交之间建立正确边界。本章解释消费组、再均衡和并发模型,帮助避免消息丢失与无边界重复。 ## 结论先行 可靠消费通常采用“处理成功后按分区提交位移”并让下游具备幂等性。消费者实例数受分区数约束;处理耗时必须受 `max.poll.interval.ms` 约束,否则会被视为失活并触发再均衡。 ## 消费者组机制  *图:orders 主题下 Group A/B 的分区分配* ``` Topic: orders (6 个分区) ┌─ Consumer Group A ──────────────────────┐ │ │ │ Consumer-1 ← P0, P1 │ │ Consumer-2 ← P2, P3 │ │ Consumer-3 ← P4, P5 │ │ │ │ 规则:一个分区只能被组内一个消费者消费 │ └─────────────────────────────────────────┘ ┌─ Consumer Group B ──────────────────────┐ │ │ │ Consumer-4 ← P0, P1, P2, P3, P4, P5 │ │ (单个消费者消费所有分区) │ └─────────────────────────────────────────┘ 两个 Group 独立消费,互不影响 ``` [查看 Consumer Group 分区分配示意图(SVG 补充资源)](/images/excalidraw/04-consumer-group-assignment-diagram.svg) [打开可编辑的 Excalidraw 源图](/images/excalidraw/04-consumer-group-assignment-diagram.excalidraw) ### 消费者数量与分区数的关系 ``` 分区数 = 6 消费者数 = 3: 每人 2 个分区 ✓ 均衡 消费者数 = 6: 每人 1 个分区 ✓ 最大并行 消费者数 = 8: 6 人各 1 个分区,2 人空闲 ✗ 浪费 消费者数 = 1: 1 人消费全部 ✓ 但无并行 ``` 结论:消费者数量 ≤ 分区数,最理想是相等。 ## Offset 管理 ### Offset 的存储 ``` Kafka 内部 Topic: __consumer_offsets(50 个分区) 存储格式: Key: (group.id, topic, partition) Value: (offset, metadata, timestamp) Consumer Group "order-service" 的 Offset: (order-service, orders, 0) → offset=1024 (order-service, orders, 1) → offset=2048 (order-service, orders, 2) → offset=512 ``` > 💬 **Q:这段是什么意思?解释说明** > > 这段描述的是 **Kafka 如何持久化存储消费者的消费进度(offset)**。 > > **核心概念:** 每个 Consumer Group 消费到每个分区的第几条消息,这个"书签"需要持久化存储,以便消费者重启后能从断点继续消费。 > > **逐行解释:** > - `__consumer_offsets`:Kafka 自动创建的**内部 Topic**(默认 50 个分区),专门存储所有消费者组的 offset。它本身也是一个 Kafka Topic,由 Kafka 内部管理,用户不需要手动创建。 > - **Key = (group.id, topic, partition)**:唯一标识"哪个消费者组 + 哪个 topic + 哪个分区"的消费进度。 > - **Value = (offset, metadata, timestamp)**:该组在该分区消费到了第几条消息、附加元数据、提交时间。 > > **例子含义:** `order-service` 消费者组消费 `orders` topic 的 3 个分区: > - 分区 0 已消费到第 1024 条(下次从 1025 开始) > - 分区 1 已消费到第 2048 条 > - 分区 2 已消费到第 512 条 > > **为什么这样设计?** > - 消费者重启或 rebalance 后,查询 `__consumer_offsets` 就能知道从哪继续消费 > - 早期 offset 存在 ZooKeeper 里,但 ZK 不适合高频写入;存在 Kafka 自身的 Topic 里利用了 Kafka 本身的高吞吐和持久化能力 > - 50 个分区是为了分散不同消费者组的 offset 写入压力(通过 `hash(group.id) % 50` 决定写入哪个分区) > 💬 **Q:不是消费者自己维护消费到哪里了吗?** > > 对,offset 确实是**消费者主动提交**的,Broker 不会自动帮你记。但"消费者自己维护"和"存在 `__consumer_offsets`"不矛盾,它们是两个层面: > > - **谁决定 offset** → 消费者自己(控制提交时机和提交的值) > - **offset 存在哪** → `__consumer_offsets` Topic(持久化在 Broker 端) > > 完整流程: > ``` > 1. 消费者 poll 到消息,内存中记录当前消费位置 > 2. 消费者主动调用 commitSync()/commitAsync(),把 offset 写入 __consumer_offsets > 3. 消费者重启时,向 Broker 查询"我上次提交的 offset 是多少" > 4. Broker 从 __consumer_offsets 读出来返回给消费者 > 5. 消费者从该 offset 继续消费 > ``` > > 如果 offset 只存在消费者内存里,消费者一挂就丢了,重启后不知道从哪继续。`__consumer_offsets` 就是消费者提交 offset 的**持久化存储后端**。 > > 类比:你看书时自己决定在哪一页夹书签(消费者决定),但书签夹在书里(存在 Broker 端),下次打开书就能找到。 ### 自动提交 vs 手动提交 ```java // ========== 自动提交(默认) ========== props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, true); props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 5000); // 每 5 秒提交 // 风险:消费完但还没到提交时间就崩溃 → 重复消费 // 提交了但还没处理完就崩溃 → 消息丢失 // ========== 手动同步提交 ========== props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false); while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000)); for (ConsumerRecord<String, String> record : records) { processRecord(record); // 处理消息 } consumer.commitSync(); // 同步提交,阻塞直到成功 // 优点:可靠 缺点:阻塞,影响吞吐量 } // ========== 手动异步提交 ========== while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000)); for (ConsumerRecord<String, String> record : records) { processRecord(record); } consumer.commitAsync((offsets, exception) -> { if (exception != null) { log.error("提交失败: {}", offsets, exception); } }); // 优点:非阻塞 缺点:失败后不会重试(可能被后续提交覆盖) } // ========== 最佳实践:异步 + 同步兜底 ========== try { while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000)); for (ConsumerRecord<String, String> record : records) { processRecord(record); } consumer.commitAsync(); // 正常情况异步提交 } } finally { consumer.commitSync(); // 关闭前同步提交,确保最后的 Offset 不丢 consumer.close(); } ``` ### 精确提交(按分区提交) ```java while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000)); for (TopicPartition partition : records.partitions()) { List<ConsumerRecord<String, String>> partitionRecords = records.records(partition); for (ConsumerRecord<String, String> record : partitionRecords) { processRecord(record); } // 提交该分区的 Offset long lastOffset = partitionRecords.get(partitionRecords.size() - 1).offset(); consumer.commitSync(Map.of( partition, new OffsetAndMetadata(lastOffset + 1) )); } } ``` ### auto.offset.reset ```java props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest"); // "earliest" — 从最早的消息开始消费(有 Offset 记录时从记录处继续) // "latest" — 从最新的消息开始消费(默认) // "none" — 没有 Offset 记录时抛异常 // 注意:只在以下情况生效: // 1. 新的消费者组(没有提交过 Offset) // 2. 之前的 Offset 已过期被删除 ``` ## Rebalance(再均衡) 当消费者组内的消费者数量发生变化时,分区会重新分配。  *图:Consumer Group 的分区再分配过程,以及 Offset 提交与恢复机制。* ### 触发条件 ``` 1. 消费者加入组 2. 消费者离开组(主动关闭或崩溃) 3. 消费者被判定为死亡(心跳超时) 4. Topic 的分区数增加 5. 订阅的 Topic 发生变化 ``` ### Rebalance 过程 ``` 阶段 1: 所有消费者停止消费,放弃当前分区 阶段 2: Group Coordinator 收集所有消费者信息 阶段 3: 选出 Consumer Leader,执行分区分配 阶段 4: 分配结果通过 Coordinator 下发给所有消费者 阶段 5: 消费者获得新的分区分配,恢复消费 问题:Rebalance 期间整个消费者组不可用(STW) ``` ### 分区分配策略 ```java // 1. Range(默认) // 按 Topic 维度,分区按范围分配 // Topic-A: P0,P1,P2,P3,P4 Consumer: C0,C1 // C0 → P0,P1,P2 C1 → P3,P4(不均匀) // 2. RoundRobin // 所有 Topic 的分区轮询分配 // C0 → P0,P2,P4 C1 → P1,P3(均匀) // 3. Sticky(推荐) // 尽量保持原有分配不变,只移动必要的分区 // 减少 Rebalance 的影响 // 4. CooperativeSticky(推荐,增量 Rebalance) // 渐进式 Rebalance,不需要全部停止消费 props.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, "org.apache.kafka.clients.consumer.CooperativeStickyAssignor"); ``` ### 避免不必要的 Rebalance ```java // 1. 合理设置心跳和会话超时 props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 45000); // 会话超时 45s props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 15000); // 心跳间隔 15s // 经验:session.timeout = 3 × heartbeat.interval // 2. 合理设置 poll 间隔 props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 300000); // 最大 poll 间隔 5 分钟 // 如果两次 poll 间隔超过此值,消费者被踢出组 // 3. 合理设置每次 poll 的记录数 props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500); // 每次最多拉取 500 条 // 减少单次处理时间,避免超过 max.poll.interval.ms ``` ### Rebalance 监听器 ```java consumer.subscribe(List.of("my-topic"), new ConsumerRebalanceListener() { @Override public void onPartitionsRevoked(Collection<TopicPartition> partitions) { // 分区被回收前调用 // 在这里提交 Offset,避免重复消费 System.out.println("分区被回收: " + partitions); consumer.commitSync(); } @Override public void onPartitionsAssigned(Collection<TopicPartition> partitions) { // 分区分配后调用 System.out.println("分区已分配: " + partitions); // 可以在这里 seek 到特定位置 } }); ``` ## 消费者核心参数 | 参数 | 默认值 | 说明 | |------|--------|------| | group.id | - | 消费者组 ID(必填) | | auto.offset.reset | latest | 无 Offset 时的起始位置 | | enable.auto.commit | true | 是否自动提交 | | auto.commit.interval.ms | 5000 | 自动提交间隔 | | session.timeout.ms | 45000 | 会话超时 | | heartbeat.interval.ms | 3000 | 心跳间隔 | | max.poll.interval.ms | 300000 | 最大 poll 间隔 | | max.poll.records | 500 | 单次 poll 最大记录数 | | fetch.min.bytes | 1 | 最小拉取字节数 | | fetch.max.wait.ms | 500 | 最大等待时间 | | max.partition.fetch.bytes | 1048576 | 每个分区最大拉取字节 | ## 指定位置消费 ```java // 从指定 Offset 消费 consumer.assign(List.of(new TopicPartition("my-topic", 0))); consumer.seek(new TopicPartition("my-topic", 0), 100); // 从 offset=100 开始 // 从头消费 consumer.seekToBeginning(consumer.assignment()); // 从末尾消费 consumer.seekToEnd(consumer.assignment()); // 按时间戳消费 Map<TopicPartition, Long> timestampMap = new HashMap<>(); timestampMap.put(new TopicPartition("my-topic", 0), 1704067200000L); // 2024-01-01 Map<TopicPartition, OffsetAndTimestamp> offsetMap = consumer.offsetsForTimes(timestampMap); for (Map.Entry<TopicPartition, OffsetAndTimestamp> entry : offsetMap.entrySet()) { consumer.seek(entry.getKey(), entry.getValue().offset()); } ``` ## 多线程消费模式 ### 模式一:每个线程一个消费者 ```java // 最简单,每个线程独立消费 for (int i = 0; i < threadCount; i++) { new Thread(() -> { KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props); consumer.subscribe(List.of("my-topic")); while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000)); for (ConsumerRecord<String, String> record : records) { processRecord(record); } } }).start(); } // 优点:简单,分区级别有序 // 缺点:线程数受分区数限制 ``` ### 模式二:单消费者 + 工作线程池 ```java // 一个消费者拉取,多个线程处理 KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props); consumer.subscribe(List.of("my-topic")); ExecutorService executor = Executors.newFixedThreadPool(8); while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000)); for (ConsumerRecord<String, String> record : records) { executor.submit(() -> processRecord(record)); } } // 优点:处理能力不受分区数限制 // 缺点:Offset 提交复杂,无法保证分区内有序 ``` ## 本章小结 - 消费者组是 Kafka 实现消息广播和负载均衡的核心机制 - 手动提交 Offset 比自动提交更可靠 - Rebalance 是消费者组的痛点,CooperativeSticky 策略可以缓解 - 消费者数量不要超过分区数 ## 思考题 1. 如何实现消费者的优雅关闭? 2. 消费者处理消息很慢,有哪些优化方案? ## 生产实践:将提交边界绑定到业务完成 单线程处理时,按分区处理成功后提交下一条 Offset 通常最简单。采用工作线程池时,不能在投递任务后立即提交;需要跟踪每个分区“已连续完成”的最大 Offset,并在分区撤销回调中停止接收、等待或取消任务后再提交。排查反复 Rebalance 时,同时检查处理耗时、GC、网络抖动、`max.poll.interval.ms` 和是否错误地共享了一个 `KafkaConsumer` 实例(它不是线程安全的)。 ## 思考题参考答案 1. **如何优雅关闭?** 停止新任务、完成或安全中止在途处理,提交已连续成功的 Offset,调用 `wakeup()` 退出 poll 循环后关闭消费者;再均衡回调也要采用同样的提交边界。 2. **处理慢如何优化?** 先区分是 Kafka 拉取、业务计算还是下游 I/O;优化下游与批处理后,再增加消费者(受分区限制)或使用保序的工作队列。不要仅增大 `max.poll.records`,否则可能触发 poll 超时。 ## 官方参考资料 - [Consumer Configs](https://kafka.apache.org/documentation/#consumerconfigs) - [Consumer API](https://kafka.apache.org/documentation/#consumerapi) - [Consumer Groups](https://kafka.apache.org/documentation/#impl_offsettracking) --- 导航:[目录](./README.md) | 上一篇:[03 - 生产者详解](./03-producer.md) | 下一篇:[05 - 主题与分区](./05-topic-partition.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入