mirror of
https://github.com/CyC2018/Interview-Notebook.git
synced 2026-11-19 12:33:46 +00:00
Update 消息队列.md
调整高频标记;补充 mandatory 与备用交换机、托管 Kafka 的 unclean 选举默认值、Redis 做队列时的 BLMOVE 与 Pub/Sub 断开连接,以及顺序性、消息堆积、延迟消息和 Kafka 存储等小节的校对。
This commit is contained in:
+40
-33
@@ -18,7 +18,7 @@
|
||||
* [六、延迟消息与死信队列](#六延迟消息与死信队列) 🔥
|
||||
* [延迟消息](#延迟消息)
|
||||
* [死信队列](#死信队列)
|
||||
* [七、Kafka](#七kafka)
|
||||
* [七、Kafka](#七kafka) 🔥
|
||||
* [分区与消费者组](#分区与消费者组)
|
||||
* [副本与可靠性](#副本与可靠性)
|
||||
* [存储](#存储)
|
||||
@@ -40,7 +40,7 @@
|
||||
|
||||
### 点对点
|
||||
|
||||
消息生产者向消息队列中发送了一个消息之后,多个消费者竞争领取,一条消息只交给其中一个消费者处理。
|
||||
消息生产者向消息队列(存储和转发消息的服务端,其中的服务器节点称为 Broker)中发送了一个消息之后,多个消费者竞争领取,一条消息只交给其中一个消费者处理。
|
||||
|
||||
<div align="center"> <img src="pics/mq-p2p.png" width="680px"/> </div><br>
|
||||
|
||||
@@ -54,7 +54,7 @@ Kafka、RocketMQ 等通过消费者组把两种模型结合起来:一条消息
|
||||
|
||||
<div align="center"> <img src="pics/consumer-group.png" width="620px"/> </div><br>
|
||||
|
||||
发布与订阅模式和观察者模式有以下不同:
|
||||
发布与订阅模式和[观察者模式](设计模式%20-%20观察者.md)(被观察的对象称为主题,它维护一张观察者列表,状态变化时逐个调用观察者)有以下不同:
|
||||
|
||||
- 观察者模式中,观察者和主题都知道对方的存在;而在发布与订阅模式中,生产者与消费者不知道对方的存在,它们之间通过频道进行通信;
|
||||
- 观察者模式是同步的,当事件触发时,主题会调用观察者的方法,然后等待方法返回;而发布与订阅模式是异步的,生产者向频道发送一个消息之后,就不需要关心消费者何时去订阅这个消息,可以立即返回。
|
||||
@@ -117,7 +117,7 @@ Kafka、RocketMQ 等通过消费者组把两种模型结合起来:一条消息
|
||||
| 存储 | 多副本,配合 min.insync.replicas,见 [副本与可靠性](#副本与可靠性) | 持久化的队列加持久化的消息,或者使用多副本的仲裁队列(Quorum Queue) | 同步刷盘(SYNC_FLUSH)加同步复制(SYNC_MASTER),默认都是异步的 |
|
||||
| 消费 | 处理完再提交偏移量 | 关闭自动确认,处理完再发送 ack | 处理完再返回 CONSUME_SUCCESS,失败返回 RECONSUME_LATER 稍后重试 |
|
||||
|
||||
需要注意的是,RabbitMQ 对无法路由到任何队列的消息同样返回 ack,只开启确认而不设置 mandatory 时,发错路由键的消息会被直接丢弃;设置了 mandatory,这类消息会先退回给生产者。
|
||||
需要注意的是,RabbitMQ 对无法路由到任何队列的消息同样返回 ack,只开启确认而不设置 mandatory 时,发错路由键的消息会被直接丢弃;设置了 mandatory,这类消息会先退回给生产者,生产者要注册处理退回消息的回调。交换机配置了备用交换机(Alternate Exchange)时,无法路由的消息会交给备用交换机尝试路由;最终路由到队列才不会退回,否则设置了 mandatory 的消息仍会退回。
|
||||
|
||||
RocketMQ 5.x 的主从部署中(未开启 Controller 模式,其它复制参数保持默认),只把 brokerRole 设为 SYNC_MASTER 不会等待从节点:需要确认的副本数由 inSyncReplicas 决定,默认为 1,即主节点写入后就返回。一主一从要同步复制时,还要把 totalReplicas 和 inSyncReplicas 都设为 2。
|
||||
|
||||
@@ -127,7 +127,7 @@ RocketMQ 5.x 的主从部署中(未开启 Controller 模式,其它复制参
|
||||
|
||||
消息队列把消息可靠地保存之后才向发送端返回确认,发送端没有收到确认就进行重传。这里的“保存”不一定是刷盘,例如 Kafka 中是写入了足够多的副本,见下文的[副本与可靠性](#副本与可靠性)。
|
||||
|
||||
需要注意的是,Kafka 生产者的 send() 是异步的,把消息放入本地的缓冲区就返回,发送和重试在后台线程中进行。既不检查返回的 Future、也不传入回调时,重试用完之后的失败没有任何人知道;进程退出前没有调用 close() 或 flush(),缓冲区中还没有发出的消息也会丢失。
|
||||
需要注意的是,Kafka 生产者的 send() 是异步的,把消息放入本地的缓冲区就返回,发送和重试在后台线程中进行。retries 默认为 Integer.MAX_VALUE,发送的总时限由 delivery.timeout.ms(默认 2 分钟)限制,遇到不可重试的错误时会提前失败。既不检查返回的 Future、也不传入回调时,最终的发送失败没有任何人知道;进程退出前没有调用 close() 或 flush(),缓冲区中还没有发出的消息也会丢失。
|
||||
|
||||
另一个问题是业务操作和发送消息不在同一个事务中:订单写库成功后进程崩溃,消息就没有发出。解决方法是[本地消息表](分布式.md#本地消息表):在同一个本地事务中写入业务数据和待发送的消息,提交后再转发,收到确认前不断重传。
|
||||
|
||||
@@ -135,17 +135,17 @@ RocketMQ 5.x 的主从部署中(未开启 Controller 模式,其它复制参
|
||||
|
||||
消息队列收到消息后需要持久化到磁盘,并复制到多个副本上,避免单个节点宕机导致消息丢失。
|
||||
|
||||
Kafka 默认不在每次写入后刷盘(log.flush.interval.messages 默认为 Long 的最大值),持久性依靠多个副本。如果所有副本所在的机器同时断电,还在页缓存中的消息仍然会丢失,所以副本要分布在不同的机架或可用区。另一个相关的配置是 unclean.leader.election.enable,默认为 false:ISR 中的副本全部不可用时,宁可让分区暂时无法写入,也不让落后的副本成为 Leader;设为 true 可以更快恢复写入,但落后的副本没有同步到的消息就丢失了。
|
||||
Kafka 默认不在每次写入后刷盘(log.flush.interval.messages 默认为 Long 的最大值),持久性依靠多个副本。如果所有副本所在的机器同时断电,还在页缓存中的消息仍然会丢失,所以副本要分布在不同的机架或可用区。另一个相关的配置是 unclean.leader.election.enable,默认为 false:ISR(与负责读写的 Leader 副本保持同步的副本集合,见[副本与可靠性](#副本与可靠性))中的副本全部不可用时,宁可让分区暂时无法写入,也不让落后的副本成为 Leader;设为 true 可以更快恢复写入,但落后的副本没有同步到的消息就丢失了。托管服务的默认值不一定相同,例如使用 Standard broker 且未启用分层存储的 Amazon MSK 集群默认为 true,不能接受丢消息时要显式设为 false。
|
||||
|
||||
### 接收端的可靠性
|
||||
|
||||
接收端在处理完成之后才向消息队列确认,处理过程中崩溃的话消息会被重新投递,不会丢失,代价是同一条消息可能被处理多次。生产者重发、消费者处理完但没来得及确认、重平衡后分区换了消费者,都会造成重复,Kafka 的幂等生产者只能去掉生产者内部重试造成的重复。
|
||||
接收端在处理完成之后才向消息队列确认,处理过程中崩溃的话消息会被重新投递,不会丢失,代价是同一条消息可能被处理多次。生产者重发、消费者处理完但没来得及确认(例如 Kafka 自动提交之前崩溃,见[副本与可靠性](#副本与可靠性)的最后两段)、重平衡后分区换了消费者(见[分区与消费者组](#分区与消费者组)),都会造成重复,Kafka 的[幂等生产者](#副本与可靠性)只能去掉生产者内部重试造成的重复。
|
||||
|
||||
RocketMQ 5.x 的 SimpleConsumer 取消息时设定不可见时间,到期仍未确认的消息会重新投递,可能由组内其它消费者收到,原消费者之后再确认会失败;预计处理不完时,要在到期前调用 changeInvisibleDuration 延长。
|
||||
|
||||
所以处理消息的逻辑要具有幂等性,同一条消息处理多次和处理一次的结果相同,常用的做法是用一张去重表记录已经处理过的消息的业务键。
|
||||
|
||||
例如积分服务消费“订单 1024 支付成功”的消息,在同一个本地事务中先写去重表、再加积分。重复的消息插入去重表时违反主键约束,回滚后直接确认这条消息:
|
||||
例如积分服务消费“订单 1024 支付成功”的消息,在同一个本地事务中先写去重表、再加积分。重复的消息插入去重表时违反主键约束。需要注意的是,MySQL 的重复键错误只撤销这条 INSERT,事务并没有结束,程序要捕获错误、执行 ROLLBACK 后再确认消息,继续执行 UPDATE 和 COMMIT 会重复加积分:
|
||||
|
||||
```sql
|
||||
BEGIN;
|
||||
@@ -160,21 +160,21 @@ COMMIT;
|
||||
|
||||
需要注意的是,消息队列提供的“恰好一次”(Exactly Once)不能代替业务的幂等。Kafka 的恰好一次指的是“从 Kafka 读取、处理、再写回 Kafka”这个过程中,用事务把输出的消息和消费的偏移量一起提交。消费者把结果写入数据库或者调用外部接口时,数据库的提交和偏移量的提交仍然是两件事,两者之间崩溃就会重复处理,Kafka 文档也说明写入其它系统时需要那个系统配合。
|
||||
|
||||
去重记录也可以放在 Redis 中,但如果用 SETNX 标记之后、处理完成之前消费者崩溃,重新投递的消息会被当作已经处理而跳过,这条消息就丢了。因此 Redis 中要区分“处理中”和“已完成”两种状态,“处理中”设置过期时间,过期后允许重新处理。过期后重新处理时,前一个处理者可能还没有结束,所以业务写入仍要用唯一索引或状态条件兜底。通用的幂等方法见 [分布式中的幂等](分布式.md#九幂等)。
|
||||
去重记录也可以放在 Redis 中,但如果用 SET NX 标记之后、处理完成之前消费者崩溃,重新投递的消息会被当作已经处理而跳过,这条消息就丢了。因此 Redis 中要区分“处理中”和“已完成”两种状态,“处理中”设置过期时间,过期后允许重新处理。过期后重新处理时,前一个处理者可能还没有结束,所以业务写入仍要用唯一索引或状态条件兜底。通用的幂等方法见 [分布式中的幂等](分布式.md#九幂等)。
|
||||
|
||||
## 四、顺序性 🔥
|
||||
|
||||
消息队列通常只保证单个队列(Kafka 中的分区)内的消息有序,多个队列之间没有顺序保证。并且在点对点模式下,一个消费者处理失败的消息会被重新投递给另一个消费者,顺序也会被打乱。
|
||||
消息队列通常只保证单个队列(Kafka 中的分区)内的消息有序,多个队列之间没有顺序保证。需要整个主题全局有序时只能使用一个队列,这时一个消费者组中只有一个消费者在处理,吞吐量受限于这一个队列。并且在点对点模式下,一个消费者处理失败的消息会被重新投递给另一个消费者,顺序也会被打乱。
|
||||
|
||||
要保证同一业务的消息有序,需要让发送端把这些消息按业务 Key(例如订单号)路由到同一个队列,并且接收端对同一个队列只用一个线程顺序消费。
|
||||
要保证同一业务的消息有序,需要让发送端把这些消息按业务 Key(例如订单号)路由到同一个队列,并且接收端对同一个队列只用一个线程顺序消费。这样一个队列同一时刻只有一个线程在处理,并发度受队列数限制;消费跟不上时,可以在消费者内部按 key 把消息分给多个线程,同一个 key 仍由同一个线程处理,见[消息堆积](#五消息堆积)。
|
||||
|
||||
发送端也要按业务顺序发送。生产者的重试也可能打乱顺序:多个批次同时在途时,“已支付”的批次失败重试,后面“已发货”的批次先写入成功。Kafka 默认开启的幂等生产者用序号避免了这种乱序,关闭幂等时要把 max.in.flight.requests.per.connection 设为 1。需要注意的是,没有显式设置 enable.idempotence 时,只要把 acks 设为 all 以外的值(例如 acks=1),幂等就会被自动关闭(只在 INFO 日志中提示一句),而 max.in.flight.requests.per.connection 仍是默认的 5,多个批次同时在途时重试乱序又会出现;retries=0 同样会关闭幂等,但这时不再重试。显式设为 true 时,冲突的配置会在启动时报错。
|
||||
发送端也要按业务顺序发送。生产者的重试也可能打乱顺序:多个批次同时在途时,“已支付”的批次失败重试,后面“已发货”的批次先写入成功。Kafka 默认开启的幂等生产者用序号(见[副本与可靠性](#副本与可靠性))避免了这种乱序,关闭幂等时要把 max.in.flight.requests.per.connection 设为 1。需要注意的是,没有显式设置 enable.idempotence 时,只要把 acks 设为 all 以外的值(例如 acks=1),幂等就会被自动关闭(只在 INFO 日志中提示一句),而 max.in.flight.requests.per.connection 仍是默认的 5,多个批次同时在途时重试乱序又会出现;retries=0 同样会关闭幂等,但这时不再重试。显式设为 true 时,冲突的配置会在启动时报错。
|
||||
|
||||
<div align="center"> <img src="pics/mq-order-by-key.png" width="760px"/> </div><br>
|
||||
|
||||
RabbitMQ 中一个队列内的消息是先进先出的,但一个队列有多个消费者时,消息被拒绝后重新入队会打乱顺序。需要顺序时按业务 Key 把消息路由到多个队列,每个队列只有一个消费者;或者开启单活跃消费者(Single Active Consumer),同一时刻只有一个消费者接收消息,它断开后才由另一个消费者接替。Kafka 中这两件事由分区和消费者组完成:同一个 key 进入同一个分区,一个分区只分配给组内的一个消费者。
|
||||
|
||||
需要注意的是,分区数改变后同一个 key 可能落到另一个分区。例如主题从 3 个分区扩为 4 个后,订单 1024 的“已支付”在分区 2,“已发货”进入了分区 1,可能先被处理(Kafka 4.4 实测,见[附录 A5](#a5-增加分区后-key-所在的分区))。所以要求顺序的主题要预先规划分区数,扩容时先暂停写入,等旧分区消费完再恢复。
|
||||
需要注意的是,分区数改变后同一个 key 可能落到另一个分区。例如主题(Topic,Kafka 中消息的分类,一个主题分成多个分区)从 3 个分区扩为 4 个后,订单 1024 的“已支付”在分区 2,“已发货”进入了分区 1,可能先被处理(Kafka 4.4 实测,见[附录 A5](#a5-增加分区后-key-所在的分区))。所以要求顺序的主题要预先规划分区数,扩容时先暂停写入,等旧分区消费完再恢复。
|
||||
|
||||
顺序消费时一条消息处理失败,后面的消息都要等它。RocketMQ 4.x 的顺序消费默认一直重试,要设置最大重试次数(maxReconsumeTimes),超过后转入[死信队列](#死信队列)。5.x 的新 SDK 按消息组(MessageGroup)保证顺序,同一消息组的消息存放在同一个队列中;一条消息超过最大重试次数后跳过,不再阻塞后面的消息(RocketMQ 5.x 文档)。
|
||||
|
||||
@@ -182,7 +182,7 @@ RabbitMQ 中一个队列内的消息是先进先出的,但一个队列有多
|
||||
|
||||
消费速度长期低于生产速度时,消息会在队列中堆积。
|
||||
|
||||
堆积的程度用积压量(Lag)衡量,Kafka 中每个分区的积压量等于日志末尾的偏移量减去消费者组已提交的偏移量。例如积分服务只消费了 3000 条就停止,用 kafka-consumer-groups.sh 查看(Kafka 4.4 实测,省略了后三列,见[附录 A3](#a3-消费积压)):
|
||||
堆积的程度用积压量(Lag)衡量,Kafka 中每个分区的积压量等于日志末尾的偏移量减去消费者组已提交的偏移量(分区和偏移量见[分区与消费者组](#分区与消费者组))。例如积分服务只消费了 3000 条就停止,用 kafka-consumer-groups.sh 查看(Kafka 4.4 实测,省略了后三列,见[附录 A3](#a3-消费积压)):
|
||||
|
||||
```text
|
||||
GROUP TOPIC PARTITION CURRENT-OFFSET LOG-END-OFFSET LAG
|
||||
@@ -195,7 +195,7 @@ points points-events 2 3000 11186 8186
|
||||
|
||||
排查时先看积压是生产突增造成的,还是消费变慢造成的:
|
||||
|
||||
- 生产突增:例如大促、批量任务,生产速率的监控会明显上升,峰值过后通常能自然消化;
|
||||
- 生产突增:例如大促、批量任务,生产速率的监控会明显上升,峰值过后通常能自然消化,需要多久可以按积压量 ÷(消费速率 − 生产速率)估算,例子见[削峰](系统设计基础.md#2-削峰);
|
||||
- 消费变慢:最常见的原因是消费逻辑依赖的数据库或外部接口变慢,其次是某些消息反复处理失败、不断重试,或者处理超时导致消费者被踢出、频繁重平衡;
|
||||
- 只有个别分区积压:通常是 key 分布不均,大量消息集中到了同一个分区。
|
||||
|
||||
@@ -207,7 +207,7 @@ points points-events 2 3000 11186 8186
|
||||
- 积压量很大、分区数又不够时,给原主题增加分区没有用,积压的消息仍在原来的分区里,可以临时新建一个分区更多的主题,原来的消费者只把消息按原来的 key 和顺序转发过去,再用更多的消费者消费新主题;
|
||||
- 不重要的消息可以降级,例如先跳过,之后再补偿。
|
||||
|
||||
需要注意的是,Kafka 按保留时间删除旧数据,不管消息有没有被消费,积压超过 retention.ms(默认 7 天)的消息会被删除;RocketMQ 默认保留 72 小时。积压的时间接近保留时间时,要先把消息转存出来。
|
||||
需要注意的是,Kafka 按保留时间删除旧数据,不管消息有没有被消费,积压超过 retention.ms(默认 7 天)的消息会被删除;RocketMQ 默认保留 72 小时,磁盘使用率超过 85% 时会提前删除最早的文件,不管是否过期(RocketMQ 4.9、5.x 源码)。积压的时间接近保留时间时,要先把消息转存出来。
|
||||
|
||||
RabbitMQ 的队列默认没有长度上限,积压的消息占用内存和磁盘,达到内存或磁盘的水位线后,RabbitMQ 会阻塞所有发布消息的连接;设置了长度上限(x-max-length)的队列满了之后,默认丢弃队头最早的消息,配置了死信交换机时转入死信队列。
|
||||
|
||||
@@ -221,9 +221,9 @@ RabbitMQ 的队列默认没有长度上限,积压的消息占用内存和磁
|
||||
|
||||
各消息队列的支持情况:
|
||||
|
||||
- RocketMQ 4.x 只支持 18 个固定的延迟级别:1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h,消息先存入内部的定时主题,每个级别一个队列,同一队列中先写入的先到期,只需检查队头;
|
||||
- RocketMQ 5.x 改用时间轮,支持指定任意的投递时间,默认精度为 1 秒;最长时长由配置决定,开源 5.x 中 gRPC 客户端经 Proxy 发送时默认最长 1 天(Proxy 的 maxDelayTimeMills),Remoting 客户端默认最长 3 天(Broker 的 timerMaxDelaySec),超出时发送失败,不会立即投递(官方文档写的是最长 24 小时、超出立即投递,与开源实现不同);
|
||||
- RabbitMQ 常用的做法是给消息设置过期时间(TTL),过期后转入死信交换机,由死信队列的消费者处理。过期的消息到达队头才会被转出,前面 30 分钟的消息会挡住后面已到期的 1 分钟的消息,所以每种延迟时长单独建一个队列;4.4 起仲裁队列也支持延迟投递(以官方最新文档为准);
|
||||
- RocketMQ 4.x 只支持 18 个固定的延迟级别:1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h,消息先存入内部的定时主题,每个级别一个队列,同一队列中先写入的先到期,只需检查队头,到期后换回原来的主题再写入一次,消费者这时才能读到;
|
||||
- RocketMQ 5.x 新增基于时间轮的定时消息(仍兼容上面的延迟级别),支持指定任意的投递时间,默认精度为 1 秒;最长时长由配置决定,开源 5.5.1 中 gRPC 客户端经 Proxy 发送时默认最长 1 天(Proxy 的 maxDelayTimeMills),Remoting 客户端默认最长 3 天(Broker 的 timerMaxDelaySec),超出时发送失败,不会立即投递(官方文档写的是最长 24 小时、超出立即投递,与开源实现不同);
|
||||
- RabbitMQ 常用的做法是给消息设置过期时间(TTL),过期后转入死信交换机,由死信队列的消费者处理。过期的消息到达队头才会被转出,前面 30 分钟的消息会挡住后面已到期的 1 分钟的消息,所以每种延迟时长单独建一个队列;也可以用延迟消息插件(rabbitmq_delayed_message_exchange),但官方已不再维护,延迟中的消息只在当前节点存一份;4.4 起仲裁队列也支持延迟投递(以官方最新文档为准);
|
||||
- Kafka 不支持延迟消息,需要自己实现,例如按延迟时长分成几个主题,消费者读到未到期的消息就暂停等待。
|
||||
|
||||
不使用消息队列时,也可以用 Redis 的有序集合实现:分值为到期时间,后台线程定期取出分值不大于当前时间的成员。多个实例同时轮询时,用 ZREM 的返回值判断由谁处理,返回 1 的实例才处理:
|
||||
@@ -259,7 +259,7 @@ DelayQueue 内部是按到期时间排序的堆,插入和取出都是 O(logN)
|
||||
|
||||
事务消息用于保证本地事务和发送消息同时成功或失败,半消息、提交和回查的过程见 [分布式事务中的事务消息](分布式.md#本地消息表)。回查时按业务数据判断:例如回查“订单 1024 已创建”时,订单表中有 1024 就提交,确认事务已结束而没有订单才回滚,无法确定时返回 Unknown 等下次回查。
|
||||
|
||||
## 七、Kafka
|
||||
## 七、Kafka 🔥
|
||||
|
||||
Kafka 把消息保存为按分区追加的日志,消息被消费后不会删除,这是它与 RabbitMQ 最大的区别。三种常用的消息队列对比如下:
|
||||
|
||||
@@ -287,8 +287,8 @@ RabbitMQ 也提供了只追加的 Stream 类型,消息确认后不删除,可
|
||||
|
||||
Redis 也常被用作轻量的消息队列,但可靠性不如专门的消息队列:
|
||||
|
||||
- Pub/Sub 不保存消息,发布时没有订阅者或者订阅者断线,消息就丢了,实测没有订阅者时 PUBLISH 返回 0;
|
||||
- List 用 LPUSH 和 BRPOP 实现队列,消息取出后就从 List 中删除,消费者处理时崩溃就丢了,也不支持多个消费者组;
|
||||
- Pub/Sub 不保存消息,发布时没有订阅者或者订阅者断线,消息就丢了,实测没有订阅者时 PUBLISH 返回 0;订阅者读取不及时,Redis 为该连接维护的输出缓冲区超过限制(默认 32 MB,或者连续 60 秒超过 8 MB)时,连接会被断开;尚未送达的消息和断线期间发布的消息都不会向该订阅者补发;
|
||||
- List 用 LPUSH 和 BRPOP 实现队列,消息取出后就从 List 中删除,消费者处理时崩溃就丢了,也不支持多个消费者组。6.2 起可以用 BLMOVE(之前是 BRPOPLPUSH)在取出的同时把消息放进“处理中”列表,处理完再用 LREM 删除,但超时未删除的消息要由应用自己放回队列;
|
||||
- Stream(Redis 5.0 起)支持消费者组和确认:XREADGROUP 读出的消息进入待确认列表,XACK 之后才移除,消费者崩溃时其它消费者可以用 XCLAIM(6.2 起也可用 XAUTOCLAIM)接管它没有确认的消息(见[附录 A4](#a4-redis-stream-的确认))。
|
||||
|
||||
即使使用 Stream,默认配置下持久化和主从复制都是异步的,宕机时可能丢失最近写入的消息。
|
||||
@@ -309,13 +309,13 @@ Kafka 中的消息按主题(Topic)分类,每个主题分成多个分区(
|
||||
|
||||
消费者以消费者组为单位订阅主题:组内每个分区只分配给一个消费者,一个消费者可以负责多个分区。所以分区数决定了一个组最多有多少个消费者同时工作,多出来的消费者只能空闲。不同的组各自独立地消费全部消息,例如计费服务和物流服务各用一个组,都能收到每一条订单消息。
|
||||
|
||||
Kafka 4.2 起提供共享组(Share Group):一个分区的消息可以分给多个消费者,消费者数可以超过分区数,每条消息单独确认,超时未确认就重新投递,代价是不再保证顺序。例如 1 个分区的主题,3 个共享消费者各处理了 40 条消息(Kafka 4.4 实测,见[附录 A6](#a6-共享组))。
|
||||
Kafka 4.2 起正式提供共享组(Share Group,4.1 为预览):一个分区的消息可以分给多个消费者,消费者数可以超过分区数,每条消息单独确认,超时未确认就重新投递,代价是不再保证顺序。例如 1 个分区的主题,3 个共享消费者各处理了 40 条消息(Kafka 4.4 实测,见[附录 A6](#a6-共享组))。
|
||||
|
||||
消费者加入、退出或者分区数变化时,组内会重新分配分区,称为重平衡(Rebalance)。默认的 classic 协议使用 RangeAssignor 分配,所有消费者先交出全部分区,整个组暂停;classic 下改用 CooperativeStickyAssignor,或者使用 Kafka 4.0 起的新协议(group.protocol=consumer,由 broker 计算分配),都只暂停需要移动的分区。例如 6 个分区的组加入第二个消费者时,第一个消费者在两种协议下分别交出 6 个和 3 个分区(Kafka 4.4 实测,见[附录 A7](#a7-重平衡时交出的分区))。
|
||||
|
||||
重平衡还可能造成重复消费。一个常见的原因是处理一批消息的时间超过了 max.poll.interval.ms(默认 5 分钟),消费者被认为已经失效,它的分区被分给其他消费者,这时它再提交偏移量会失败。失去分区并不会中断正在执行的业务逻辑,旧消费者可能还在处理已经拉取的消息,与接管的消费者重叠,处理完再提交时才失败。可以调小 max.poll.records 或调大 max.poll.interval.ms;正常的重平衡可以在 ConsumerRebalanceListener 的 onPartitionsRevoked 中先同步提交已处理完的偏移量,再交出分区。
|
||||
|
||||
发布新版本时,消费者收到 SIGTERM 后设置停止标志,并在另一个线程调用 wakeup();消费线程处理完当前一批,处理好 WakeupException 后提交已完成的偏移量,再调用 close()。默认的动态成员调用 close() 时会主动离开消费者组,分区很快被接管;进程被 SIGKILL 强制终止时,通常要等会话超时后才会重新分配分区。
|
||||
发布新版本时,消费者收到 SIGTERM 后设置停止标志,并在另一个线程调用 wakeup();消费线程处理完当前一批,处理好 WakeupException 后提交已完成的偏移量,再调用 close()。默认的动态成员调用 close() 时会主动离开消费者组,分区很快被接管;进程被 SIGKILL 强制终止时,通常要等会话超时(默认的 classic 协议中由 session.timeout.ms 决定,默认 45 秒)后才会重新分配分区。
|
||||
|
||||
### 副本与可靠性
|
||||
|
||||
@@ -348,9 +348,9 @@ Follower 落后几条消息时仍在 ISR 中,Leader 宕机后它可以成为
|
||||
|
||||
<div align="center"> <img src="pics/kafka-acks1-loss.png" width="760px"/> </div><br>
|
||||
|
||||
acks=all 要配合 min.insync.replicas(默认为 1)使用,否则 ISR 只剩 Leader 一个时,acks=all 就退化成了 acks=1。min.insync.replicas 设为 2 时,ISR 少于 2 个副本,broker 就拒绝 acks=all 的写入。上面停掉 broker 3 之后 ISR 还有 2 个副本,写入正常;把 min.insync.replicas 改为 3 再写入,生产者重试几次后报错 NotEnoughReplicasException;改用 acks=1 时写入成功,但高水位不前进,停掉的 broker 回到 ISR 后消费者才能读到这条消息(Kafka 4.4 实测,见[附录 A8](#a8-mininsyncreplicas-与-acks))。常用的配置是 3 个副本、min.insync.replicas=2、acks=all,一个副本故障时既不丢消息,也不停止写入。
|
||||
acks=all 要配合 min.insync.replicas(默认为 1)使用,否则 ISR 只剩 Leader 一个时,acks=all 就退化成了 acks=1。min.insync.replicas 设为 2 时,ISR 少于 2 个副本,broker 就拒绝 acks=all 的写入。上面停掉 broker 3 之后 ISR 还有 2 个副本,写入正常;把 min.insync.replicas 改为 3 再写入,生产者重试几次后报错 NotEnoughReplicasException;改用 acks=1 时写入成功,但 Kafka 4.x 中 ISR 少于 min.insync.replicas 时,不论 acks 取什么,高水位都不前进,停掉的 broker 回到 ISR 后消费者才能读到这条消息(Kafka 4.4 实测,见[附录 A8](#a8-mininsyncreplicas-与-acks))。常用的配置是 3 个副本、min.insync.replicas=2、acks=all,一个副本故障时既不丢消息,也不停止写入。
|
||||
|
||||
生产者没有收到确认就会重试,这可能让同一条消息写入两次。Kafka 3.0 起默认开启幂等生产者(3.0.0、3.1.0 因缺陷未生效):broker 给每个生产者分配一个 ID,生产者给发往每个分区的消息编上序号,broker 发现序号重复就丢弃。后文查看 .log 文件时,每个批次都带有 producerId: 1001 和 baseSequence 字段。幂等只保证单个分区内、生产者自身重试时不重复,应用自己重发的消息不能去重;要让写入多个分区的消息同时成功或失败,需要使用事务,消费者设置 isolation.level=read_committed 后只读取已提交事务中的消息。
|
||||
生产者没有收到确认就会重试,这可能让同一条消息写入两次。Kafka 3.0 起默认开启幂等生产者(3.0.0、3.1.0 因缺陷未生效):broker 给每个生产者分配一个 ID,生产者给发往每个分区的消息编上序号,broker 发现序号重复就丢弃。下文[存储](#存储)一节用 kafka-dump-log.sh 查看 .log 文件时,每个批次都带有 producerId: 1001 和 baseSequence 字段。幂等只保证单个分区内、生产者自身重试时不重复,应用自己重发的消息不能去重;要让写入多个分区的消息同时成功或失败,需要使用事务,消费者设置 isolation.level=read_committed 后只读取已提交事务中的消息。
|
||||
|
||||
消费者处理完消息后提交偏移量,下次从提交的位置继续读取。默认每 5 秒自动提交一次,已经处理但还没提交时崩溃,重启后可能重复消费。例如消费者读到 3 条扣款消息后被 kill -9,这时组还没有提交过偏移量;它在 session.timeout.ms(默认 45 秒)之后被移出消费者组,重新启动的消费者从哪里开始由 auto.offset.reset 决定:设为 earliest 时从最早的消息开始,又收到了这 3 条消息;默认的 latest 从末尾开始,这 3 条不会再被自动读到(Kafka 4.4 实测,见[附录 A2](#a2-重复消费))。新的消费者组第一次订阅,或者已提交的偏移量对应的消息已被删除时,也按这个配置决定。因此接收端必须做到幂等,方法见 [接收端的可靠性](#接收端的可靠性)。反过来,如果先提交偏移量再处理,处理失败的消息就丢失了。
|
||||
|
||||
@@ -371,7 +371,9 @@ acks=all 要配合 min.insync.replicas(默认为 1)使用,否则 ISR 只
|
||||
00000000000000028416.index 10485760
|
||||
```
|
||||
|
||||
.index 是稀疏索引,每写入一段数据(index.interval.bytes,默认 4 KB)记录一条“偏移量 → 在 .log 文件中的位置”。查找偏移量 20000 的消息:
|
||||
最后一个段正在写入,它的索引文件预先分配了 10 MB,并用 mmap(见[为什么吞吐量高](#为什么吞吐量高))映射到内存,段写满后才截断为实际大小。
|
||||
|
||||
.index 是稀疏索引,每写入一段数据(index.interval.bytes,默认 4 KB)记录一条“批次的最后一个偏移量 → 这个批次在 .log 文件中的起始位置”。查找偏移量 20000 的消息:
|
||||
|
||||
1. 按文件名二分查找,20000 落在 00000000000000018944 这个段中;
|
||||
2. 在这个段的索引中二分查找,不大于 20000 的最近一条索引是 19979 → 97662;
|
||||
@@ -379,7 +381,7 @@ acks=all 要配合 min.insync.replicas(默认为 1)使用,否则 ISR 只
|
||||
|
||||
<div align="center"> <img src="pics/kafka-index-lookup.png" width="760px"/> </div><br>
|
||||
|
||||
正在写入的段的索引文件预先分配了 10 MB,并用 mmap 映射到内存,段写满后才截断为实际大小。用 kafka-dump-log.sh 查看 .log 文件,可以看到消息是按批次存放的,这里每个批次有 148 条消息、16277 字节,接近生产者批次大小的默认值 16 KB。
|
||||
用 kafka-dump-log.sh 查看 .log 文件,可以看到消息是按批次存放的,这里每个批次有 148 条消息、16277 字节,接近生产者批次大小的默认值 16 KB。
|
||||
|
||||
旧数据按保留时间(默认 7 天)或总大小清理,每次删除一整个段,不需要修改文件内容;也可以配置为日志压缩,每个 key 只保留最新的一条消息。
|
||||
|
||||
@@ -389,11 +391,11 @@ acks=all 要配合 min.insync.replicas(默认为 1)使用,否则 ISR 只
|
||||
|
||||
批量:生产者把发往同一个分区的消息攒成批次再发送,批次在网络传输、写入日志和副本复制时都作为一个整体处理,压缩也以批次为单位。例如在 3 个节点的集群上发送 2 万条 100 字节的消息(acks=all),默认配置每秒约 5.7 万~6.8 万条,平均延迟 21~54 ms;设置 batch.size=0(linger.ms=0)关闭批量后,每秒只有约 6500~6800 条,发送的请求大量排队,平均延迟约 1.4 秒(Kafka 4.4 实测,见[附录 A1](#a1-批量对吞吐量的影响))。
|
||||
|
||||
零拷贝:零拷贝(Zero-copy)指的是传输数据时,CPU 不在内核空间和用户空间之间来回拷贝数据。用 read() 和 write() 把文件发到网络时,数据从页缓存拷贝到应用的缓冲区,再拷贝到 Socket 缓冲区,共 4 次拷贝、2 次系统调用。broker 把日志发给消费者时使用 sendfile 系统调用,数据只在内核中传递(启用 SSL,包括 SASL_SSL 时,数据要读到用户空间加密,不能使用 sendfile,但读的仍是页缓存;SASL_PLAINTEXT 只认证、不加密,仍使用 sendfile):
|
||||
零拷贝:零拷贝(Zero-copy)指的是传输数据时,CPU 不在内核空间和用户空间之间来回拷贝数据。用 read() 和 write() 把文件发到网络时,数据先由 DMA 从磁盘读入页缓存,再由 CPU 拷贝到应用的缓冲区和 Socket 缓冲区,最后由 DMA 拷贝到网卡,共 4 次拷贝、2 次系统调用。broker 把日志发给消费者时使用 sendfile 系统调用,数据只在内核中传递(启用 SSL,包括 SASL_SSL 时,数据要读到用户空间加密,不能使用 sendfile,但读的仍是页缓存;SASL_PLAINTEXT 只认证、不加密,仍使用 sendfile):
|
||||
|
||||
<div align="center"> <img src="pics/zero-copy.png" width="760px"/> </div><br>
|
||||
|
||||
另一种减少拷贝的方法是内存映射(mmap):把文件映射到进程的地址空间,进程读写这段内存就是直接读写页缓存,不需要 read() 和 write() 的拷贝。第一次访问某一页时触发缺页异常,由内核把这一页从磁盘读入页缓存,再建立映射。前文 Kafka 的索引文件、RocketMQ 的 CommitLog 都是用 mmap 读写的。
|
||||
另一种减少拷贝的方法是内存映射(mmap):把文件映射到进程的地址空间,进程读写这段内存就是直接读写页缓存,不需要 read() 和 write() 的拷贝。访问还没有建立映射的页时触发缺页异常,内核先在页缓存中找,找不到才从磁盘读入,再建立映射,缺页的处理过程见[内存管理](计算机操作系统%20-%20内存管理.md#分页系统地址映射)。前文 Kafka 的索引文件、RocketMQ 的 CommitLog 都是用 mmap 读写的。
|
||||
|
||||
用 mmap 映射文件后再调用 write() 发给 Socket 时,省掉的只是页缓存到应用缓冲区的一次拷贝,页缓存到 Socket 缓冲区仍要由 CPU 拷贝一次,共 3 次拷贝、2 次系统调用(mmap() 和 write())。
|
||||
|
||||
@@ -521,7 +523,7 @@ $ redis-cli publish ch:orders 1024 # 没有订阅者
|
||||
|
||||
### A5 增加分区后 key 所在的分区
|
||||
|
||||
A5~A8 在另一个新建的同样配置的集群上运行,Java 程序用 JDK 21 和 Kafka 4.4.0 的客户端。主题 addp 先建 3 个分区,写入 4 个订单的“pay”,扩为 4 个分区后再写入“ship”:
|
||||
A5~A8 在另一个新建的同样配置的集群上运行(端口 29091~29093),Java 程序用 JDK 21 和 Kafka 4.4.0 的客户端。主题 addp 先建 3 个分区,写入 4 个订单的“pay”,扩为 4 个分区后再写入“ship”:
|
||||
|
||||
```text
|
||||
$ printf '1024:pay\n1025:pay\n1026:pay\n1027:pay\n' | kafka-console-producer.sh --bootstrap-server $B --topic addp \
|
||||
@@ -589,13 +591,18 @@ B 分到 [3, 4, 5],现在持有 [3, 4, 5]
|
||||
|
||||
### A8 min.insync.replicas 与 acks
|
||||
|
||||
主题 hw 有 1 个分区、3 个副本,Leader 为 broker 1。先写入 m1,kill -9 broker 2,再把 min.insync.replicas 改为 3,用 acks=1 写入 m3:
|
||||
主题 hw 有 1 个分区、3 个副本,Leader 为 broker 1。先写入 m1,kill -9 broker 2,再把 min.insync.replicas 改为 3,先用默认的 acks=all 写入 m2(retries=3),再用 acks=1 写入 m3:
|
||||
|
||||
```text
|
||||
$ kafka-topics.sh --bootstrap-server $B --describe --topic hw
|
||||
Topic: hw Partition: 0 Leader: 1 Replicas: 1,2,3 Isr: 1,3
|
||||
$ echo "1025:m2" | kafka-console-producer.sh ... --command-property retries=3
|
||||
WARN ... retrying (2 attempts left). Error: NOT_ENOUGH_REPLICAS
|
||||
WARN ... retrying (1 attempts left). Error: NOT_ENOUGH_REPLICAS
|
||||
WARN ... retrying (0 attempts left). Error: NOT_ENOUGH_REPLICAS
|
||||
org.apache.kafka.common.errors.NotEnoughReplicasException: Messages are rejected since there are fewer in-sync replicas than required.
|
||||
$ echo "1026:m3" | kafka-console-producer.sh ... --command-property acks=1 # 正常返回
|
||||
$ kafka-console-consumer.sh --bootstrap-server $B --topic hw --from-beginning --property print.offset=true
|
||||
$ kafka-console-consumer.sh --bootstrap-server $B --topic hw --from-beginning --formatter-property print.offset=true
|
||||
Offset:0 m1
|
||||
Processed a total of 1 messages
|
||||
$ kafka-get-offsets.sh --bootstrap-server $B --topic hw
|
||||
|
||||
Reference in New Issue
Block a user