RocketMQ

目录

RocketMQ概述

一、MQ概述 

二、基本概念

三、系统架构

客户端工作流程

集群搭建理论

RocketMQ工作原理

---

RocketMQ概述

一、MQ概述 

1、MQ简介

MQ，Message Queue，是一种提供消息队列服务的中间件，也称为消息中间件，是一套提供了消息生 产、存储、消费全过程API的软件系统。消息即数据。一般消息的体量不会很大。

2、MQ用途

限流削峰 ：MQ可以将系统的超量请求暂存其中，以便系统后期可以慢慢进行处理，从而避免了请求的丢失或系统 被压垮。

异步解耦：上游系统对下游系统的调用若为同步调用，则会大大降低系统的吞吐量与并发度，且系统耦合度太高。 而异步调用则会解决这些问题。所以两层之间若要实现由同步到异步的转化，一般性做法就是，在这两 层间添加一个MQ层。

数据收集：分布式系统会产生海量级数据流，如：业务日志、监控数据、用户行为等。针对这些数据流进行实时或批量采集汇总，然后对这些数据流进行大数据分析，这是当前互联网平台的必备技术。通过MQ完成此 类数据收集是最好的选择。

3、常见MQ产品

RabbitMQ：RabbitMQ是使用ErLang语言开发的一款MQ产品。其吞吐量较Kafka与RocketMQ要低，且由于其不是 Java语言开发，所以公司内部对其实现定制化开发难度较大。

Kafka：Kafka是使用Scala/Java语言开发的一款MQ产品。其最大的特点就是高吞吐率，常用于大数据领域的实时计算、日志采集等场景。其没有遵循任何常见的MQ协议，而是使用自研协议。对于Spring Cloud Netçix，其仅支持RabbitMQ与Kafka。

RocketMQ：RocketMQ是使用Java语言开发的一款MQ产品。经过数年阿里双11的考验，性能与稳定性非常高。其 没有遵循任何常见的MQ协议，而是使用自研协议。对于Spring Cloud Alibaba，其支持RabbitMQ、 Kafka，但提倡使用RocketMQ。

 4、MQ常见协议

JMS：JMS，Java Messaging Service（Java消息服务）。是Java平台上有关MOM（Message Oriented Middleware，面向消息的中间件 PO/OO/AO）的技术规范，它便于消息系统中的Java应用程序进行消 息交换，并且通过提供标准的产生、发送、接收消息的接口，简化企业应用的开发。ActiveMQ是该协议的典型实现。

STOMP：STOMP，Streaming Text Orientated Message Protocol（面向流文本的消息协议），是一种MOM设计 的简单文本协议。STOMP提供一个可互操作的连接格式，允许客户端与任意STOMP消息代理 （Broker）进行交互。ActiveMQ是该协议的典型实现，RabbitMQ通过插件可以支持该协议。

AMQP：AMQP，Advanced Message Queuing Protocol（高级消息队列协议），一个提供统一消息服务的应用层标准，是应用层协议的一个开放标准，是一种MOM设计。基于此协议的客户端与消息中间件可传递 消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制。 RabbitMQ是该协议的典型实 现。

MQTT：MQTT，Message Queuing Telemetry Transport（消息队列遥测传输），是IBM开发的一个即时通讯协 议，是一种二进制协议，主要用于服务器和低功耗IoT（物联网）设备间的通信。该协议支持所有平 台，几乎可以把所有联网物品和外部连接起来，被用来当做传感器和致动器的通信协议。 RabbitMQ通 过插件可以支持该协议。

二、基本概念

消息（Message）：消息是指，消息系统所传输信息的物理载体，生产和消费数据的最小单位，每条消息必须属于一个主 题。

主题（Topic）：Topic表示一类消息的集合，每个主题包含若干条消息，每条消息只能属于一个主题，是RocketMQ进行消息订阅的基本单位。 topic:message 1:n message:topic 1:1。

一个生产者可以同时发送多种Topic的消息；而一个消费者只对某种特定的Topic感兴趣，即只可以订阅和消费一种Topic的消息。 producer:topic 1:n consumer:topic 1:1。

标签（Tag）：为消息设置的标签，用于同一主题下区分不同类型的消息。来自同一业务单元的消息，可以根据不同业务目的在同一主题下设置不同标签。标签能够有效地保持代码的清晰度和连贯性，并优化RocketMQ提 供的查询系统。消费者可以根据Tag实现对不同子主题的不同消费逻辑，实现更好的扩展性。

队列（Queue）：存储消息的物理实体。一个Topic中可以包含多个Queue，每个Queue中存放的就是该Topic的消息。一 个Topic的Queue也被称为一个Topic中消息的分区（Partition）。 一个Topic的Queue中的消息只能被一个消费者组中的一个消费者消费。一个Queue中的消息不允许同 一个消费者组中的多个消费者同时消费。

消息标识（MessageId/Key）：RocketMQ中每个消息拥有唯一的MessageId，且可以携带具有业务标识的Key，以方便对消息的查询。

不过需要注意的是，MessageId有两个：

在生产者send()消息时会自动生成一个MessageId（msgId)，

当消息到达Broker后，Broker也会自动生成一个MessageId(offsetMsgId)。

msgId、offsetMsgId与key都称为消息标识。

msgId：由producer端生成，其生成规则为： producerIp + 进程pid + MessageClientIDSetter类的ClassLoader的hashCode + 当前时间 + AutomicInteger自增计数器

offsetMsgId：由broker端生成，其生成规则为：brokerIp + 物理分区的offset（Queue中的偏移量）

key：由用户指定的业务相关的唯一标识。

三、系统架构

RocketMQ架构上主要分为四部分构成：

Producer 消息生产者，负责生产消息。

Producer通过MQ的负载均衡模块选择相应的Broker集群队列进行消息投递，投递的过程支持快速失败并且低延迟。 例如，业务系统产生的日志写入到MQ的过程，就是消息生产的过程；再如，电商平台中用户提交的秒杀请求写入到MQ的过程，就是消息生产的过程 RocketMQ中的消息生产者都是以生产者组（Producer Group）的形式出现的。

生产者组是同一类生产者的集合，这类Producer发送相同Topic类型的消息。一个生产者组可以同时发送多个主题的消息。

Consumer 消息消费者，负责消费消息。

一个消息消费者会从Broker服务器中获取到消息，并对消息进行相关业务处理。 例如，QoS系统从MQ中读取日志，并对日志进行解析处理的过程就是消息消费的过程。 再如，电商平台的业务系统从MQ中读取到秒杀请求，并对请求进行处理的过程就是消息消费的过程。

RocketMQ中的消息消费者都是以消费者组（Consumer Group）的形式出现的。消费者组是同一类消费者的集合，这类Consumer消费的是同一个Topic类型的消息。消费者组使得在消息消费方面，实现负载均衡（将一个Topic中的不同的Queue平均分配给同一个Consumer Group的不同的Consumer，注意，并不是将消息负载均衡）和容错（一个Consmer挂了，该Consumer Group中的其它Consumer可以接着消费原Consumer消费的Queue）的目标变得非常容易。 

消费者组中Consumer的数量应该小于等于订阅Topic的Queue数量。如果超出Queue数量，则多出的 Consumer将不能消费消息。

不过，一个Topic类型的消息可以被多个消费者组同时消费。

注意：

1）消费者组只能消费一个Topic的消息，不能同时消费多个Topic消息

2）一个消费者组中的消费者必须订阅完全相同的Topic

NameServer是一个Broker与Topic路由的注册中心，支持Broker的动态注册与发现。

RocketMQ的思想来自于Kafka，而Kafka是依赖了Zookeeper的。所以，在RocketMQ的早期版本，即在 MetaQ v1.0与v2.0版本中，也是依赖于Zookeeper的。从MetaQ v3.0，即RocketMQ开始去掉了 Zookeeper依赖，使用了自己的NameServer。

主要包括两个功能：

Broker管理：接受Broker集群的注册信息并且保存下来作为路由信息的基本数据；提供心跳检测 机制，检查Broker是否还存活。

路由信息管理：每个NameServer中都保存着Broker集群的整个路由信息和用于客户端查询的队列 信息。Producer和Conumser通过NameServer可以获取整个Broker集群的路由信息，从而进行消 息的投递和消费。

路由注册

NameServer通常也是以集群的方式部署，不过，NameServer是无状态的，即NameServer集群中的各 个节点间是无差异的，各节点间相互不进行信息通讯。

那各节点中的数据是如何进行数据同步的呢？在 Broker节点启动时，轮询NameServer列表，与每个NameServer节点建立长连接，发起注册请求。在 NameServer内部维护着⼀个Broker列表，用来动态存储Broker的信息。

注意，这是与其它像zk、Eureka、Nacos等注册中心不同的地方。 这种NameServer的无状态方式，有什么优缺点：

优点：NameServer集群搭建简单，扩容简单。

缺点：对于Broker，必须明确指出所有NameServer地址。否则未指出的将不会去注册。也正因为如此，NameServer并不能随便扩容。因为，若Broker不重新配置，新增的NameServer对于 Broker来说是不可见的，其不会向这个NameServer进行注册。

Broker节点为了证明自己是活着的，为了维护与NameServer间的长连接，会将最新的信息以心跳包的方式上报给NameServer，每30秒发送一次心跳。心跳包中包含 BrokerId、Broker地址(IP+Port)、 Broker名称、Broker所属集群名称等等。NameServer在接收到心跳包后，会更新心跳时间戳，记录这个Broker的最新存活时间。

路由剔除

由于Broker关机、宕机或网络抖动等原因，NameServer没有收到Broker的心跳，NameServer可能会将其从Broker列表中剔除。

NameServer中有⼀个定时任务，每隔10秒就会扫描⼀次Broker表，查看每一个Broker的最新心跳时间 戳距离当前时间是否超过120秒，如果超过，则会判定Broker失效，然后将其从Broker列表中剔除。

扩展：对于RocketMQ日常运维工作，例如Broker升级，需要停掉Broker的工作。OP需要怎么 做？

OP需要将Broker的读写权限禁掉。一旦client(Consumer或Producer)向broker发送请求，都会收 到broker的NO_PERMISSION响应，然后client会进行对其它Broker的重试。 当OP观察到这个Broker没有流量后，再关闭它，实现Broker从NameServer的移除。

OP：运维工程师 SRE：Site Reliability Engineer，现场可靠性工程师

路由发现

RocketMQ的路由发现采用的是Pull模型。当Topic路由信息出现变化时，NameServer不会主动推送给客户端，而是客户端定时拉取主题最新的路由。默认客户端每30秒会拉取一次最新的路由。 扩展：

1）Push模型：推送模型。其实时性较好，是一个“发布-订阅”模型，需要维护一个长连接。而长连接的维护是需要资源成本的。

该模型适合的场景： 实时性要求较高 Client数量不多，Server数据变化较频繁

2）Pull模型：拉取模型。存在的问题是，实时性较差。

3）Long Polling模型：长轮询模型。其是对Push与Pull模型的整合，充分利用了这两种模型的优 势，屏蔽了它们的劣势。Polling是指不管服务端数据有无更新，客户端每隔定长时间请求拉取一次数据，可能有更新数据返回，也可能什么都没有。

客户端发起Long Polling，此时如果服务端没有相关数据，会hold住请求，直到服务端有相关数据，或者等待一定时间超时才会返回。返回后，客户端又会立即再次发起下一次Long Polling。这种方式也是对拉模式的一个优化，解决了拉模式数据通知不及时，以及减少了大量的无效轮询次数。（所谓的hold住请求指的服务端暂时不回复结果，保存相关请求，不关闭请求连接，等相关数据准备好，写会客户端。）

客户端NameServer选择策略

这里的客户端指的是Producer与Consumer

客户端在配置时必须要写上NameServer集群的地址，那么客户端到底连接的是哪个NameServer节点呢？

客户端首先会生产一个随机数，然后再与NameServer节点数量取模，此时得到的就是所要连接的 节点索引，然后就会进行连接。如果连接失败，则会采用round-robin策略，逐个尝试着去连接其它节 点。

首先采用的是随机策略进行的选择，失败后采用的是轮询策略。

扩展：Zookeeper Client是如何选择Zookeeper Server的？ 简单来说就是，经过两次Shuffle，然后选择第一台Zookeeper Server。 详细说就是，将配置文件中的zk server地址进行第一次shuffle，然后随机选择一个。这个选择出 的一般都是一个hostname。然后获取到该hostname对应的所有ip，再对这些ip进行第二次 shuffle，从shuffle过的结果中取第一个server地址进行连接。

Broker充当着消息中转角色，负责存储消息、转发消息。

Broker在RocketMQ系统中负责接收并存储从生产者发送来的消息，同时为消费者的拉取请求作准备。

Broker同时也存储着消息相关的元数据，包括消费者组消费进度偏移offset（集群消费）、主题、队列等。

Kafka 0.8版本之后，offset是存放在Broker中的，之前版本是存放在Zookeeper中的。

模块构成

Remoting Module：整个Broker的实体，负责处理来自clients端的请求。而这个Broker实体则由以下模 块构成。

Client Manager：客户端管理器。负责接收、解析客户端(Producer/Consumer)请求，管理客户端。例 如，维护Consumer的Topic订阅信息

Store Service：存储服务。提供方便简单的API接口，处理消息存储(mmap)到物理硬盘和消息查询功能。

HA Service：高可用服务，提供Master Broker 和 Slave Broker之间的数据同步功能。

Index Service：索引服务。根据特定的Message key，对投递到Broker的消息进行索引服务，同时也提供根据Message Key对消息进行快速查询的功能。 

集群部署

为了增强Broker性能与吞吐量，Broker一般都是以集群形式出现的。各集群节点中可能存放着相同 Topic的不同Queue。不过，这里有个问题，如果某Broker节点宕机，如何保证数据不丢失呢？其解决方案是，将每个Broker集群节点进行横向扩展，即将Broker节点再建为一个HA集群，解决单点问题。

Broker节点集群是一个主从集群，即集群中具有Master与Slave两种角色。Master负责处理读写操作请 求，Slave负责对Master中的数据进行备份。当Master挂掉了，Slave则会自动切换为Master去工作。所以这个Broker集群是主备集群。

一个Master可以包含多个Slave，但一个Slave只能隶属于一个Master。

Master与Slave 的对应关系是通过指定相同的BrokerName、不同的BrokerId 来确定的。

BrokerId为0表示Master，非0表示Slave。每个Broker与NameServer集群中的所有节点建立长连接，定时注册Topic信息到所有NameServer。 

在多主多从架构下，由于每个master可以配置多个slave，所以如果其中一个master挂了，那么只是当前Broker不能写消息了，但Consumer仍然可以从slave节点消费到。可以完美的实现rocketmq消息的高可用。master挂了的话，slave节点不会转变为master，也就是会导致集群不可用。

客户端工作流程

1）启动NameServer，NameServer启动后开始监听端口，等待Broker、Producer、Consumer连接。

2）启动Broker时，Broker会与所有的NameServer建立并保持长连接，然后每30秒向NameServer定时 发送心跳包。

3）发送消息前，可以先创建Topic，创建Topic时需要指定该Topic要存储在哪些Broker上，当然，在创建Topic时也会将Topic与Broker的关系写入到NameServer中。不过，这步是可选的，也可以在发送消息时自动创建Topic。

4）Producer发送消息，启动时先跟NameServer集群中的其中一台建立长连接，并从NameServer中获取路由信息，即当前发送的Topic消息的Queue与Broker的地址（IP+Port）的映射关系。然后根据算法策略选择一个Queue，与队列所在的Broker建立长连接从而向Broker发消息。当然，在获取到路由信息后，Producer会首先将路由信息缓存到本地，再每30秒从NameServer更新一次路由信息。

5）Consumer跟Producer类似，跟其中一台NameServer建立长连接，获取其所订阅Topic的路由信息， 然后根据算法策略从路由信息中获取到其所要消费的Queue，然后直接跟Broker建立长连接，开始消费其中的消息。Consumer在获取到路由信息后，同样也会每30秒从NameServer更新一次路由信息。不过，不同于Producer的是，Consumer还会向Broker发送心跳，以确保Broker的存活状态。

Topic的创建模式

手动创建Topic时，有两种模式：

集群模式：该模式下创建的Topic在该集群中，所有Broker中的Queue数量是相同的。

Broker模式：该模式下创建的Topic在该集群中，每个Broker中的Queue数量可以不同。 自动创建Topic时，默认采用的是Broker模式，会为每个Broker默认创建4个Queue。

读/写队列从物理上来讲，读/写队列是同一个队列。所以，不存在读/写队列数据同步问题。读/写队列是逻辑上进行区分的概念。一般情况下，读/写队列数量是相同的。

 例如，创建Topic时设置的写队列数量为8，读队列数量为4，此时系统会创建8个Queue，分别是0 1 2 3 4 5 6 7。Producer会将消息写入到这8个队列，但Consumer只会消费0 1 2 3这4个队列中的消息，4 5 6 7中的消息是不会被消费到的。

再如，创建Topic时设置的写队列数量为4，读队列数量为8，此时系统会创建8个Queue，分别是0 1 2 3 4 5 6 7。Producer会将消息写入到0 1 2 3 这4个队列，但Consumer只会消费0 1 2 3 4 5 6 7这8个队列中 的消息，但是4 5 6 7中是没有消息的。此时假设Consumer Group中包含两个Consuer，Consumer1消 费0 1 2 3，而Consumer2消费4 5 6 7。但实际情况是，Consumer2是没有消息可消费的。

方便Topic的Queue的缩容

例如，原来创建的Topic中包含16个Queue，如何能够使其Queue缩容为8个，还不会丢失消息？可以动 态修改写队列数量为8，读队列数量不变。此时新的消息只能写入到前8个队列，而消费都消费的却是 16个队列中的数据。当发现后8个Queue中的消息消费完毕后，就可以再将读队列数量动态设置为8。整 个缩容过程，没有丢失任何消息。

perm用于设置对当前创建Topic的操作权限：2表示只写，4表示只读，6表示读写。

集群搭建理论

复制与刷盘示意图

复制策略

复制策略是Broker的Master与Slave间的数据同步方式。分为同复制与异步复制：

同步复制：消息写入master后，master会等待slave同步数据成功后才向producer返回成功ACK

异步复制：消息写入master后，master立即向producer返回成功ACK，无需等待slave同步数据成 功 异步复制策略会降低系统的写入延迟，RT变小，提高了系统的吞吐量

刷盘策略

刷盘策略指的是broker中消息的落盘方式，即消息发送到broker内存后消息持久化到磁盘的方式。分为 同步刷盘与异步刷盘：

同步刷盘：当消息持久化到broker的磁盘后才算是消息写入成功。

异步刷盘：当消息写入到broker的内存后即表示消息写入成功，无需等待消息持久化到磁盘。

1）异步刷盘策略会降低系统的写入延迟，RT变小，提高了系统的吞吐量

2）消息写入到Broker的内存，一般是写入到了PageCache

3）对于异步刷盘策略，消息会写入到PageCache后立即返回成功ACK。但并不会立即做落盘操 作，而是当PageCache到达一定量时会自动进行落盘。

常见的四种集群模式：

单Master

• - 优点：除了配置简单没什么优点
• - 缺点：不可靠，该机器重启或宕机，将导致整个服务不可用

多Master

同一Topic的各个Queue会平均分布在各个master节点 上。

• - 优点：配置简单，性能高
  • 单个Master宕机或重启维护对应用无影响，在磁盘配置为RAID10时，即使机器宕机不可恢复情况下，由于RAID10磁盘非常可靠，消息也不会丢（异步刷盘丢失少量消息，同步刷盘一条不丢），性能最高
• - 缺点：可能会有少量消息丢失（配置相关），单台机器重启或宕机期间，该机器下未被消费的消息在机器恢复前不可订阅，影响消息实时性

多Master多Slave模式-异步复制

broker集群由多个master构成，每个master又配置了多个slave（在配置了RAID磁盘阵列的情况下，一 个master一般配置一个slave即可）。

master与slave的关系是主备关系，即master负责处理消息的读写请求，而slave仅负责消息的备份与master宕机后的角色切换。

异步复制即前面所讲的复制策略中的异步复制策略，即消息写入master成功后，master立即向 producer返回成功ACK，无需等待slave同步数据成功。

该模式的最大特点之一是，当master宕机后slave能够自动切换为master。不过由于slave从master的同步具有短暂的延迟（毫秒级），所以当master宕机后，这种异步复制方式可能会存在少量消息的丢失问题。

Slave从Master同步的延迟越短，其可能丢失的消息就越少 对于Master的RAID磁盘阵列，若使用的也是异步复制策略，同样也存在延迟问题，同样也可能会丢失消息。但RAID阵列的秘诀是微秒级的（因为是由硬盘支持的），所以其丢失的数据量会更少。

多Master多Slave模式-同步双写

该模式是多Master多Slave模式的同步复制实现。

所谓同步双写，指的是消息写入master成功后， master会等待slave同步数据成功后才向producer返回成功ACK，即master与slave都要写入成功后才会返回成功ACK，也即双写。

该模式与异步复制模式相比，优点是消息的安全性更高，不存在消息丢失的情况。但单个消息的RT略 高，从而导致性能要略低（大约低10%）。

该模式存在一个大的问题：对于目前的版本，Master宕机后，Slave不会自动切换到Master。

磁盘阵列RAID

镜像技术

镜像技术是一种冗余技术，为磁盘提供数据备份功能，防止磁盘发生故障而造成数据丢失。对于 RAID 而言，采用镜像技术最典型地的用法就是，同时在磁盘阵列中产生两个完全相同的数据副本，并且分布在两个不同的磁盘上。

镜像提供了完全的数据冗余能力，当一个数据副本失效不可用时，外部系统仍可正常访问另一副本，不会对应用系统运行和性能产生影响。而且，镜像不需要额外的计算和校验，故障修复非常快，直接复制即可。

镜像技术可以从多个副本进行并发读取数据，提供更高的读 I/O 性能，但不能并行写数据，写多个副本通常会导致一定的 I/O 性能下降。

镜像技术提供了非常高的数据安全性，其代价也是非常昂贵的，需要至少双倍的存储空间。高成本限制 了镜像的广泛应用，主要应用于至关重要的数据保护，这种场合下的数据丢失可能会造成非常巨大的损 失。

数据条带技术

数据条带化技术是一种自动将 I/O操作负载均衡到多个物理磁盘上的技术。更具体地说就是，将一块连续的数据分成很多小部分并把它们分别存储到不同磁盘上。这就能使多个进程可以并发访问数据的多个不同部分，从而获得最大程度上的 I/O 并行能力，极大地提升性能。

RAID分类

从实现角度看， RAID 主要分为软 RAID、硬 RAID 以及混合 RAID 三种。

软 RAID：所有功能均有操作系统和 CPU 来完成，没有独立的 RAID 控制处理芯片和 I/O 处理芯片，效率自然最低。

硬 RAID 配备了专门的 RAID 控制处理芯片和 I/O 处理芯片以及阵列缓冲，不占用 CPU 资源。效率很高，但成本也很高。

混合 RAID 具备 RAID 控制处理芯片，但没有专门的I/O 处理芯片，需要 CPU 和驱动程序来完成。性能和成本在软 RAID 和硬 RAID 之间

RAID10

RAID10是一个RAID1与RAID0的组合体，所以它继承了RAID0的快速和RAID1的安全。 简单来说就是，先做条带，再做镜像。发即将进来的数据先分散到不同的磁盘，再将磁盘中的数据做 镜像。

RAID10要比RAID01的容错率再高，所以生产环境下一般是不使用RAID01的。

RocketMQ工作原理

一、消息的生产

消息的生产过程

Producer可以将消息写入到某Broker中的某Queue中，其经历了如下过程：

• Producer发送消息之前，会先向NameServer发出获取消息Topic的路由信息的请求
• NameServer返回该Topic的路由表及Broker列表
• Producer根据代码中指定的Queue选择策略，从Queue列表中选出一个队列，用于后续存储消息
• Produer对消息做一些特殊处理，例如，消息本身超过4M，则会对其进行压缩 Producer向选择出的Queue所在的Broker发出RPC请求，将消息发送到选择出的Queue

路由表：

实际是一个Map，key为Topic名称，value是一个QueueData实例列表。

QueueData并不是一个Queue对应一个QueueData，而是一个Broker中该Topic的所有Queue对应一个 QueueData。

即，只要涉及到该Topic的Broker，一个Broker对应一个QueueData。QueueData中包含brokerName。

简单来说，路由表的key为Topic名称，value则为所有涉及该Topic的 BrokerName列表

Broker列表：

其实际也是一个Map。key为brokerName，value为BrokerData。

一套brokerName名称相同的Master-Slave小集群对应一个BrokerData。

BrokerData中包含brokerName及一个map。

该map的key为brokerId，value为该 broker对应的地址。

brokerId为0表示该broker为Master，非0表示Slave。

Queue选择算法

对于无序消息，其Queue选择算法，也称为消息投递算法，常见的有两种：

轮询算法

默认选择算法。该算法保证了每个Queue中可以均匀的获取到消息。 该算法存在一个问题：由于某些原因，在某些Broker上的Queue可能投递延迟较严重。从而导致 Producer的缓存队列中出现较大的消息积压，影响消息的投递性能。

最小投递延迟算法

该算法会统计每次消息投递的时间延迟，然后根据统计出的结果将消息投递到时间延迟最小的Queue。

如果延迟相同，则采用轮询算法投递。该算法可以有效提升消息的投递性能。

该算法也存在一个问题：消息在Queue上的分配不均匀。投递延迟小的Queue其可能会存在大量 的消息。而对该Queue的消费者压力会增大，降低消息的消费能力，可能会导致MQ中消息的堆积。

---

二、消息的存储

RocketMQ中的消息存储在本地文件系统中，这些相关文件默认在当前用户主目录下的store目录中。

abort：该文件在Broker启动后会自动创建，正常关闭Broker，该文件会自动消失。若在没有启动 Broker的情况下，发现这个文件是存在的，则说明之前Broker的关闭是非正常关闭。

checkpoint：其中存储着commitlog、consumequeue、index文件的最后刷盘时间戳

commitlog：其中存放着commitlog文件，而消息是写在commitlog文件中的

config：存放着Broker运行期间的一些配置数据

consumequeue：其中存放着consumequeue文件，队列就存放在这个目录中

index：其中存放着消息索引文件indexFile

lock：运行期间使用到的全局资源锁

---

commitlog文件

说明：在很多资料中commitlog目录中的文件简单就称为commitlog文件。但在源码中，该文件被命名为mappedFile。

commitlog目录中存放着很多的mappedFile文件，当前Broker中的所有消息都是落盘到这些 mappedFile文件中的。

mappedFile文件大小为1G（小于等于1G），文件名由20位十进制数构成，表示当前文件的第一条消息的起始位移偏移量。

第一个文件名一定是20位0构成的。因为第一个文件的第一条消息的偏移量commitlog offset为0 当第一个文件放满时，则会自动生成第二个文件继续存放消息。

假设第一个文件大小是 1073741820字节（1G = 1073741824字节），则第二个文件名就是00000000001073741824。 以此类推，第n个文件名应该是前n-1个文件大小之和。

一个Broker中所有mappedFile文件的commitlog offset是连续的。

需要注意的是，一个Broker中仅包含一个commitlog目录，所有的mappedFile文件都是存放在该目录中的。

即无论当前Broker中存放着多少Topic的消息，这些消息都是被顺序写入到了mappedFile文件中 的。也就是说，这些消息在Broker中存放时并没有被按照Topic进行分类存放。

mappedFile文件是顺序读写的文件，所有其访问效率很高 无论是SSD磁盘还是SATA磁盘，通常情况下，顺序存取效率都会高于随机存取。

消息单元

mappedFile文件内容由一个个的消息单元构成。

每个消息单元中包含消息总长度MsgLen、消息的物理位置physicalOffset、消息体内容Body、消息体长度BodyLength、消息主题Topic、Topic长度 TopicLength、消息生产者BornHost、消息发送时间戳BornTimestamp、消息所在的队列QueueId、消息在Queue中存储的偏移量QueueOffset等近20余项消息相关属性。 

一个mappedFile文件中第m+1个消息单元的commitlog offset偏移量：L(m+1) = L(m) + MsgLen(m) (m >= 0)

---

consumequeue

为了提高效率，会为每个Topic在~/store/consumequeue中创建一个目录，目录名为Topic名称。

在该 Topic目录下，会再为每个该Topic的Queue建立一个目录，目录名为queueId。

每个目录中存放着若干 consumequeue文件，consumequeue文件是commitlog的索引文件，可以根据consumequeue定位到具体的消息。

consumequeue文件名也由20位数字构成，表示当前文件的第一个索引条目的起始位移偏移量。与 mappedFile文件名不同的是，其后续文件名是固定的。因为consumequeue文件大小是固定不变的。

索引条目

每个consumequeue文件可以包含30w个索引条目，每个索引条目包含了三个消息重要属性：

消息在 mappedFile文件中的偏移量CommitLog Offset、消息长度、消息Tag的hashcode值。

这三个属性占20 个字节，所以每个文件的大小是固定的30w * 20字节。 一个consumequeue文件中所有消息的Topic一定是相同的。但每条消息的Tag可能是不同的。

对文件的读写

消息写入

一条消息进入到Broker后经历了以下几个过程才最终被持久化。

• Broker根据queueId，获取到该消息对应索引条目要在consumequeue目录中的写入偏移量，即 QueueOffset

  • 消息偏移量的更新分为下面几步：RocketMQ源码分析之ConsumeQueue - 知乎 (zhihu.com)

    1：ReputMessageService不断从CommitLog中查询是否有新存储的消息；

    2：如果有新消息，便通过Dispatcher通知ConsumeQueue；

    3：ConsumeQueue收到通知后会将消息偏移量存储到自身的MappedFile中。

• 将queueId、queueOffset等数据，与消息一起封装为消息单元
• 将消息单元写入到commitlog 同时，形成消息索引条目
• 将消息索引条目分发到相应的consumequeue

消息拉取

当Consumer来拉取消息时会经历以下几个步骤：

• Consumer获取到其要消费消息所在Queue的消费偏移量offset，计算出其要消费消息的消息offset
  • 消费offset即消费进度，consumer对某个Queue的消费offset，即消费到了该Queue的第几 条消息 消息offset = 消费offset + 1
• Consumer向Broker发送拉取请求，其中会包含其要拉取消息的Queue、消息offset及消息 Tag。
• Broker计算在该consumequeue中的queueOffset。 queueOffset = 消息offset * 20字节
• 从该queueOffset处开始向后查找第一个指定Tag的索引条目。
• 解析该索引条目的前8个字节，即可定位到该消息在commitlog中的commitlog offset
• 从对应commitlog offset中读取消息单元，并发送给Consumer

性能提升

RocketMQ中，无论是消息本身还是消息索引，都是存储在磁盘上的。其不会影响消息的消费吗？当然不会。其实RocketMQ的性能在目前的MQ产品中性能是非常高的。因为系统通过一系列相关机制大大提升了性能。

首先，RocketMQ对文件的读写操作是通过mmap零拷贝进行的，将对文件的操作转化为直接对内存地址进行操作，从而极大地提高了文件的读写效率。

其次，consumequeue中的数据是顺序存放的，还引入了PageCache的预读取机制，使得对 consumequeue文件的读取几乎接近于内存读取，即使在有消息堆积情况下也不会影响性能。

PageCache机制，页缓存机制，是OS对文件的缓存机制，用于加速对文件的读写操作。一般来 说，程序对文件进行顺序读写的速度几乎接近于内存读写速度，主要原因是由于OS使用 PageCache机制对读写访问操作进行性能优化，将一部分的内存用作PageCache。

写操作：OS会先将数据写入到PageCache中，随后会以异步方式由pdflush（page dirty flush) 内核线程将Cache中的数据刷盘到物理磁盘

读操作：若用户要读取数据，其首先会从PageCache中读取，若没有命中，则OS在从物理磁盘上加载该数据到PageCache的同时，也会顺序对其相邻数据块中的数据进行预读取。

RocketMQ中可能会影响性能的是对commitlog文件的读取。因为对commitlog文件来说，读取消息时 会产生大量的随机访问，而随机访问会严重影响性能。不过，如果选择合适的系统IO调度算法，比如设置调度算法为Deadline（采用SSD固态硬盘的话），随机读的性能也会有所提升。

两种零拷贝方式

传统标准IO的方式（基于数据拷贝）

传统标准IO通过网络传输数据，需要进行如下调用：

buffer = File.read 
Socket.send(buffer)

总共需要四步：

1. read()：涉及到两次上下文切换以及两次数据拷贝；
   1. 读取磁盘文件，将数据DMA Copy到操作系统内核缓冲区Page Cache；
   2. 将内核缓冲区Page Cache的数据，CPU Copy到应用程序缓存；
2. send()：涉及到两次上下文切换以及两次数据拷贝；
   1. 将应用程序缓存中的数据，CPU Copy到socket网络发送缓冲区，即Socket Cache；
   2. 将Socket Cache的数据，DMA Copy到网卡，由网卡进行网络传输。

可以发现，完成一次读写，需要4次上下文切换、2次DMA数据拷贝、两次CPU数据拷贝，实际上，如果仅仅是数据传输，那么数据根本不需要经过这么多次的拷贝。

DMA：Direct Memory Access ，它可以独立地直接读写系统内存，不需要 CPU 介入，像显卡、网卡之类都会用DMA。

零拷贝（Zero-copy）技术是指计算机执行操作时，CPU不需要先将数据从某处内存复制到另一个特定区域。这种技术通常用于通过网络传输数据时节省CPU周期和内存带宽。零拷贝技术可以减少数据拷贝和共享总线操作的次数，消除传输数据在存储器之间不必要的中间拷贝次数，从而有效地提高数据传输效率。而且，零拷贝技术减少了用户进程地址空间和内核地址空间之间因为上下文切换而带来的开销。

常见的零拷贝技术分类：

1. 直接 I/O：数据直接跨过内核缓冲区，在用户地址空间与 I/O 设备之间传递，内核只是进行必要的虚拟存储配置等辅助工作；
2. 数据传输不经过用户空间：当应用程序在数据传输过程中不需要对数据进行访问时，则可以避免将数据从内核空间到用户空间之间的拷贝，传输的数据在页缓存中就可以得到处理；Linux 中提供类似的系统调用主要有 mmap()，sendfile() 以及 splice()。
3. 写时复制：数据不需要提前拷贝，而是当需要修改的时候再进行部分拷贝。COW是对数据在 Linux 的页缓存和用户进程的缓冲区之间的传输过程进行优化手段。

下面介绍数据传输不经过用户空间的零拷贝技术：mmap和sendfile，这也是Netty、Kafka、RocketMQ等框架所使用的底层技术。

sendfile调用

Linux 在版本 2.1 中引入了 sendfile() 这个系统调用，sendfile()是一种零拷贝的实现。Java对sendfile的支持就是NIO中的FileChannel.transferTo()或者transferFrom()。

使用sendfile进行网络数据传输流程为：

1. 发起sendfile() 系统调用，上下文切换一次。将文件中的数据DMA Copy到Page Cache中。
2. 继续将Page Cache中的数据CPU Copy到与 Scocket Cache中去。
3. 继续将Scocket Cache的数据DMA Copy到网卡，由网卡进行网络传输。sendfile() 系统调用返回，上下文切换一次。

可以看到整个流程，减少了一次CPU Copy，减少了两次的上下文切换，相比于传统IO确实提升了性能。

但是，数据仍旧需要一次从Page Cache到Socket Cache的CPU Copy，这个Copy能不能也去掉呢？

当然可以，Linux 2.4+ 版本之后，文件描述符结果被改变，借助DMA Gather(带有收集功能的DMA)，sendfile()再次减少了一次 Copy 操作，变成了真正的零拷贝（没有CPU Copy）。

此时整个步骤变为：

1. 发起sendfile() 系统调用，上下文切换一次。将文件中的数据DMA Copy到Page Cache中。
2. 继续将Page Cache中的带有文件位置和长度信息的缓冲区描述符CPU Copy到Socket Cache中去，这部分拷贝很少的数据，可忽略。
3. 继续借助DMA Gather ，直接将Scocket Cache的真正数据DMA Copy到网卡，由网卡进行网络传输。这样就避免了最后一次CPU Copy。sendfile() 系统调用返回，上下文切换一次。

sendfile + DMA Gather流程如下：

sendfile + DMA Gather，使得整个传输只需要两次上下文切换，数据只需要两次DMA Copy，降低了上下文切换和数据拷贝带来的开销，极大的提升了数据传输的效率，没有CUP拷贝，是真正的零拷贝。

但是，sendfile调用有一个缺点，那就是无法在sendfile调用过程中修改数据，因此sendfile()只是适用于应用程序地址空间不需要对所访问数据进行处理的和修改情况，常见的就是文件传输，或者MQ消费消息的获取，如果想要在传输过程中修改数据，可以使用mmap系统调用。

mmap调用是一个比sendfile调用昂贵但优于传统I/O的零拷贝实现方式，而mmap调用则可以在中途直接修改Page Cache中的数据，这也是mmap零拷贝的优点。

mmap调用

mmap（Memory Mapped Files）是一种零拷贝技术，学名内存映射文件，Java中的实现就是MappedByteBuffer，通过channel#map方法得到。

mmap将一个文件(或者文件的一部分)映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。注意这时候没有分配和映射到具体的物理内存空间，而是到第一次加载这个文件的时候，通过MMU把之前虚拟地址换算成物理地址，把文件加载进物理内存——内核空间的Page Cache中。

实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用 read，write 等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。

简单的说，使用mmap之后，数据无需拷贝到用户空间中，应用程序可以直接操作Page Cache中的数据。

mmap()代替read()调用之后的数据发送流程为：

buf = mmap(file, len);
write(sockfd, buf, len);
复制代码

使用mmap技术之后，数据流转图如下：

此时整个步骤变为：

1. mmap()：涉及到两次上下文切换以及一次数据拷贝；
   1. 发出mmap系统调用，发生一次上下文切换。通过DMA引擎将磁盘文件中的内容拷贝到内核空间的一个缓冲区（Page Cache）中。
   2. mmap系统调用返回，发生一次上下文切换。此后用户空间和内核空间共享这个缓冲区，用户空间就可以像在操作自己缓冲区中数据一般操作这个由内核空间共享的缓冲区数据，而不需要将数据在内核空间和用户空间之间来回拷贝。
2. write()：涉及到两次上下文切换以及两次数据拷贝；
   1. 发起write调用，发生一次上下文切换。将缓冲区（Page Cache）的内容CPU Copy到Socket Cache。
   2. 将Socket Cache的数据，DMA Copy到网卡，由网卡进行网络传输。write调用返回，发生一次上下文切换。

这种mmap+write的方式相比于传统IO少了一次CPU Copy，从而极大地提高了效率。虽然性能弱于sendfile零拷贝，但其好处是可以在中途修改内存中的数据之后再传输。

另外，当应用程序往 mmap 输出数据时，此时就直接输出到了内核态的缓冲区数据，如果此时输出设备是磁盘的话，不会立即写磁盘，linux系统下通常会间隔是30秒由操作系统自动落盘，也可手动调用fsync()函数让其立即落盘，实现真正的持久化。

与Kafka的对比

RocketMQ的很多思想来源于Kafka，其中commitlog与consumequeue就是。

RocketMQ中的commitlog目录与consumequeue的结合就类似于Kafka中的partition分区目录。 mappedFile文件就类似于Kafka中的segment段。

Kafka中的Topic的消息被分割为一个或多个partition。partition是一个物理概念，对应到系统上 就是topic目录下的一个或多个目录。每个partition中包含的文件称为segment，是具体存放消息 的文件。 Kafka中消息存放的目录结构是：topic目录下有partition目录，partition目录下有segment文件 Kafka中没有二级分类标签Tag这个概念

---

三、indexFile

提供了根据key进行消息查询的功能。该查询 是通过store目录中的index子目录中的indexFile进行索引实现的快速查询。当然，这个indexFile中的索 引数据是在包含了key的消息被发送到Broker时写入的。如果消息中没有包含key，则不会写入。

索引条目结构

每个Broker中会包含一组indexFile，每个indexFile都是以一个时间戳命名的（这个indexFile被创建时 的时间戳）。

每个indexFile文件由三部分构成：indexHeader，slots槽位，indexes索引数据。每个 indexFile文件中包含500w个slot槽。而每个slot槽又可能会挂载很多的index索引单元。在实际存储时，Indexes是在Slots后面的。

indexHeader固定40个字节，其中存放着如下数据： 

• beginTimestamp：该indexFile中第一条消息的存储时间
• endTimestamp：该indexFile中最后一条消息存储时间
• beginPhyoffset：该indexFile中第一条消息在commitlog中的偏移量commitlog offset
• endPhyoffset：该indexFile中最后一条消息在commitlog中的偏移量commitlog offset
• hashSlotCount：已经填充有index的slot数量（并不是每个slot槽下都挂载有index索引单元，这 里统计的是所有挂载了index索引单元的slot槽的数量）
• indexCount：该indexFile中包含的索引单元个数（统计出当前indexFile中所有slot槽下挂载的所有index索引单元的数量之和） 

key的hash值 % 500w的结果即为slot槽位，然后将该slot值修改为该index索引单元的indexNo，根 据这个indexNo可以计算出该index单元在indexFile中的位置。

不过，该取模结果的重复率是很高的， 为了解决该问题，在每个index索引单元中增加了preIndexNo，用于指定该slot中当前index索引单元的前一个index索引单元。而slot中始终存放的是其下最新的index索引单元的indexNo。

只要找到了slot就可以找到其最新的index索引单元，而通过这个index索引单元就可以找到其之前的所有 index索引单元。

indexNo是一个在indexFile中的流水号，从0开始依次递增。即在一个indexFile中所有indexNo是 以此递增的。

indexNo在index索引单元中是没有体现的，其是通过indexes中依次数出来的。

index索引单元默写20个字节，其中存放着以下四个属性：

• keyHash：消息中指定的业务key的hash值
• phyOffset：当前key对应的消息在commitlog中的偏移量commitlog offset
• timeDiff：当前key对应消息的存储时间与当前indexFile创建时间的时间差
• preIndexNo：当前slot下当前index索引单元的前一个index索引单元的indexNo

indexFile的创建

indexFile的文件名为当前文件被创建时的时间戳。

这个时间戳有什么用处呢？ 根据业务key进行查询时，查询条件除了key之外，还需要指定一个要查询的时间戳，表示要查询不大于该时间戳的最新的消息，即查询指定时间戳之前存储的最新消息。这个时间戳文件名可以简化查询，提高查询效率。

indexFile文件是何时创建的？

其创建的条件（时机）有两个：

• 当第一条带key的消息发送来后，系统发现没有indexFile，此时会创建第一个indexFile文件
• 当一个indexFile中挂载的index索引单元数量超出2000w个时，会创建新的indexFile。
  • 当带key的消息发送到来后，系统会找到最新的indexFile，并从其indexHeader的最后4字节中读取到 indexCount。
  • 若indexCount >= 2000w时，会创建新的indexFile。
  • 可以推算出，一个indexFile的最大大小是：(40 + 500w * 4 + 2000w * 20)字节

查询流程

---

四、消息的消费

消费者从Broker中获取消息的方式有两种：pull拉取方式和push推动方式。

消费者组对于消息消费的模式又分为两种：集群消费Clustering和广播消费Broadcasting。

1、消费类型

拉取式消费：Consumer主动从Broker中拉取消息，主动权由Consumer控制。一旦获取了批量消息，就会启动消费过程。不过，该方式的实时性较弱，即Broker中有了新的消息时消费者并不能及时发现并消费。 由于拉取时间间隔是由用户指定的，所以在设置该间隔时需要注意平稳：间隔太短，空请求比例会增加；间隔太长，消息的实时性太差

推送式消费：该模式下Broker收到数据后会主动推送给Consumer。该获取方式一般实时性较高。 该获取方式是典型的发布-订阅模式，即Consumer向其关联的Queue注册了监听器，一旦发现有新的 消息到来就会触发回调的执行，回调方法是Consumer去Queue中拉取消息。而这些都是基于Consumer 与Broker间的长连接的。长连接的维护是需要消耗系统资源的。

对比 pull：需要应用去实现对关联Queue的遍历，实时性差；但便于应用控制消息的拉取

push：封装了对关联Queue的遍历，实时性强，但会占用较多的系统资源

2 、消费模式

广播消费

广播消费模式下，相同Consumer Group的每个Consumer实例都接收同一个Topic的全量消息。即每条消息都会被发送到Consumer Group中的每个Consumer。

集群消费

集群消费模式下，相同Consumer Group的每个Consumer实例平均分摊同一个Topic的消息。即每条消 息只会被发送到Consumer Group中的某个Consumer。

消息进度保存

广播模式：消费进度保存在consumer端。因为广播模式下consumer group中每个consumer都会 消费所有消息，但它们的消费进度是不同。所以consumer各自保存各自的消费进度。

集群模式：消费进度保存在broker中。consumer group中的所有consumer共同消费同一个Topic 中的消息，同一条消息只会被消费一次。消费进度会参与到了消费的负载均衡中，故消费进度是需要共享的（存放在/store/config/consumerOffset.json）。

Rebalance机制

Rebalance机制讨论的前提是：集群消费。

Rebalance即再均衡，指的是，将⼀个Topic下的多个Queue在同⼀个Consumer Group中的多个 Consumer间进行重新分配的过程。

Rebalance机制的本意是为了提升消息的并行消费能力。

例如，⼀个Topic下5个队列，在只有1个消费者的情况下，这个消费者将负责消费这5个队列的消息。如果此时我们增加⼀个消费者，那么就可以给 其中⼀个消费者分配2个队列，给另⼀个分配3个队列，从而提升消息的并行消费能力。

Rebalance限制

由于一个队列最多分配给消息组中的一个消费者，因此当某个消费者组下的消费者实例数量大于队列的数量时， 多余的消费者实例将分配不到任何队列。

Rebalance危害

Rebalance的在提升消费能力的同时，也带来一些问题：

• 消费暂停：在只有一个Consumer时，其负责消费所有队列；在新增了一个Consumer后会触发 Rebalance的发生。此时原Consumer就需要暂停部分队列的消费，等到这些队列分配给新的Consumer 后，这些暂停消费的队列才能继续被消费。
• 消费重复：Consumer 在消费新分配给自己的队列时，必须接着之前Consumer 提交的消费进度的offset 继续消费。然而默认情况下，offset是异步提交的，这个异步性导致提交到Broker的offset与Consumer 实际消费的消息并不一致。这个不一致的差值就是可能会重复消费的消息。
  • 同步提交：consumer提交了其消费完毕的一批消息的offset给broker后，需要等待broker的成功 ACK。当收到ACK后，consumer才会继续获取并消费下一批消息。在等待ACK期间，consumer 是阻塞的。
  • 异步提交：consumer提交了其消费完毕的一批消息的offset给broker后，不需要等待broker的成 功ACK。consumer可以直接获取并消费下一批消息。 对于一次性读取消息的数量，需要根据具体业务场景选择一个相对均衡的是很有必要的。因为 数量过大，系统性能提升了，但产生重复消费的消息数量可能会增加；数量过小，系统性能会 下降，但被重复消费的消息数量可能会减少。
• 消费突刺：由于Rebalance可能导致重复消费，如果需要重复消费的消息过多，或者因为Rebalance暂停 时间过长从而导致积压了部分消息。那么有可能会导致在Rebalance结束之后瞬间需要消费很多消息。

Rebalance产生的原因

导致Rebalance产生的原因，无非就两个：

消费者所订阅Topic的Queue数量发生变化，或消费者组中消费者的数量发生变化。

1）Queue数量发生变化的场景：

• Broker扩容或缩容
• Broker升级运维
• Broker与NameServer间的网络异常
• Queue扩容或缩容

2）消费者数量发生变化的场景：

• Consumer Group扩容或缩容
• Consumer升级运维
• Consumer与NameServer间网络异常

Rebalance过程

在Broker中维护着多个Map集合，这些集合中动态存放着当前Topic中Queue的信息、Consumer Group 中Consumer实例的信息。

一旦发现消费者所订阅的Queue数量发生变化，或消费者组中消费者的数量发生变化，立即向Consumer Group中的每个实例发出Rebalance通知。

TopicConfigManager：key是topic名称，value是TopicConfig。

• TopicConfig中维护着该Topic中所有Queue的数据。

ConsumerManager：key是Consumser Group Id，value是ConsumerGroupInfo。

• ConsumerGroupInfo中维护着该Group中所有Consumer实例数据。
  • ConsumerGroupInfo里面存储了该group里面订阅的topic信息，同样使用map存储，key是topic，所以当相同group下面的消费者，订阅的topic如果不一致，就会覆盖map里面的值。

ConsumerOffsetManager：key为Topic与订阅该Topic的Group的组合,即topic@group， value是一个内层Map。内层Map的key为QueueId，内层Map的value为该Queue的消费进度 offset。

Consumer实例在接收到通知后会采用Queue分配算法自己获取到相应的Queue，即由Consumer实例自主进行Rebalance。

与Kafka对比

在Kafka中，一旦发现出现了Rebalance条件，Broker会调用Group Coordinator来完成Rebalance。

Coordinator是Broker中的一个进程。Coordinator会在Consumer Group中选出一个Group Leader。由 这个Leader根据自己本身组情况完成Partition分区的再分配。这个再分配结果会上报给Coordinator， 并由Coordinator同步给Group中的所有Consumer实例。

Kafka中的Rebalance是由Consumer Leader完成的。而RocketMQ中的Rebalance是由每个Consumer自身完成的，Group中不存在Leader。

---

Queue分配算法

一个Topic中的Queue只能由Consumer Group中的一个Consumer进行消费，而一个Consumer可以同时消费多个Queue中的消息。

那么Queue与Consumer间的配对关系是如何确定的，即Queue要分配给哪个Consumer进行消费，也是有算法策略的。

常见的有四种策略。这些策略是通过在创建Consumer时的构造器传进去的。

平均分配策略

该算法是要根据avg = QueueCount / ConsumerCount 的计算结果进行分配的。

如果能够整除， 则按顺序将avg个Queue逐个分配Consumer；

如果不能整除，则将多余出的Queue按照Consumer顺序逐个分配。

该算法即，先计算好每个Consumer应该分得几个Queue，然后再依次将这些数量的Queue逐个分配个Consumer。

环形平均策略

环形平均算法是指，根据消费者的顺序，依次在由queue队列组成的环形图中逐个分配。 该算法不用事先计算每个Consumer需要分配几个Queue，直接一个一个分即可。

一致性hash策略

该算法会将consumer的hash值作为Node节点存放到hash环上，然后将queue的hash值也放到hash环上，通过顺时针方向，距离queue最近的那个consumer就是该queue要分配的consumer。 该算法存在的问题：分配不均。

同机房策略

该算法会根据queue的部署机房位置和consumer的位置，过滤出当前consumer相同机房的queue。然后按照平均分配策略或环形平均策略对同机房queue进行分配。如果没有同机房queue，则按照平均分配策略或环形平均策略对所有queue进行分配。

对比

一致性hash算法存在的问题： 两种平均分配策略的分配效率较高，一致性hash策略的较低。

因为一致性hash算法较复杂。另外，一致性hash策略分配的结果也很大可能上存在不平均的情况。

一致性hash算法存在的意义： 其可以有效减少由于消费者组扩容或缩容所带来的大量的Rebalance。

一致性hash算法的应用场景： Consumer数量变化较频繁的场景。

---

至少一次原则

RocketMQ有一个原则：每条消息必须要被成功消费一次。 那么什么是成功消费呢？

Consumer在消费完消息后会向其消费进度记录器提交其消费消息的offset， offset被成功记录到记录器中，那么这条消费就被成功消费了。

什么是消费进度记录器？

对于广播消费模式来说，Consumer本身就是消费进度记录器。

对于集群消费模式来说，Broker是消费进度记录器。

五、订阅关系的一致性

RocketMQ为什么要保证订阅关系的一致性？ - 迷走神经 - 博客园 (cnblogs.com)

订阅关系的一致性指的是，同一个消费者组（Group ID相同）下所有Consumer实例所订阅的Topic与 Tag及对消息的处理逻辑必须完全一致。否则，消息消费的逻辑就会混乱，甚至导致消息丢失。

数据结构如下：

org.apache.rocketmq.broker.client.ConsumerManager：

private final ConcurrentMap consumerTable =
  new ConcurrentHashMap(1024);

这意味着集群中的每个消费者在向 broker 注册订阅信息的时候相互覆盖掉对方的订阅信息了（循环注册消费者订阅信息），这也是为什么同一个消费组应该拥有完全一样的订阅关系的原因

假设有消费者组 g1，g1下有消费者 c1 和消费者 c2，c1 订阅了 topicA，c2 订阅了 topicB，此时c2 先启动，将 g1 的订阅信息更新为 topicB，c1 随后启动，将 g1 的订阅信息覆盖为 topicA，c1 的 Rebalance 负载将 topicA 的 pullRequest 添加到 pullRequestQueue 中，而恰好此时 c2 心跳包又将 g1 的订阅信息更新为 topicB，那么此时 c1 的 PullMessageService 线程拿到 pullRequestQueue 中 topicA 的 pullRequest 进行消息拉取，然而在 broker 端找不到消费者组 g1 下 topicA 的订阅信息（因为此时恰好被 c2 心跳包给覆盖了），就会报消费者订阅信息不存在的错误了。

六、offset管理

这里的offset指的是Consumer的消费进度offset。

消费进度offset是用来记录每个Queue的不同消费组的消费进度的。根据消费进度记录器的不同，可以 分为两种模式：本地模式和远程模式。

offset本地管理模式

当消费模式为广播消费时，offset使用本地模式存储。因为每条消息会被所有的消费者消费，每个消费者管理自己的消费进度，各个消费者之间不存在消费进度的交集。

• Consumer在广播消费模式下offset相关数据以json的形式持久化到Consumer本地磁盘文件中
• 默认文件路径为当前用户主目录下的.rocketmq_offsets/${clientId}/${group}/Offsets.json 。 其中${clientId}为当前消费者id，默认为ip@DEFAULT；${group}为消费者组名称。

offset远程管理模式

当消费模式为集群消费时，offset使用远程模式管理。

因为所有Cosnumer实例对消息采用的是均衡消费，所有Consumer共享Queue的消费进度。

Consumer在集群消费模式下offset相关数据以json的形式持久化到Broker磁盘文件中，文件路径为当前 用户主目录下的store/config/consumerOffset.json 。

Broker启动时会加载这个文件，并写入到一个双层Map（ConsumerOffsetManager）。

外层map的key 为topic@group，value为内层map。内层map的key为queueId，value为offset。

当发生Rebalance时， 新的Consumer会从该Map中获取到相应的数据来继续消费。

集群模式下offset采用远程管理模式，主要是为了保证Rebalance机制。

offset用途

消费者是如何从最开始持续消费消息的？消费者要消费的第一条消息的起始位置是用户自己通过 consumer.setConsumeFromWhere()方法指定的。

Properties properties = new Properties(); 
properties.put(PropertyKeyConst.GROUP_ID, "GID_jodie_test_3"); 
Consumer consumer = ONSFactory.createConsumer(properties); consumer.subscribe("jodie_test_A", "TagB", new MessageListener() { 
    public Action consume(Message message, ConsumeContext context) {                     
       System.out.println(message.getMsgID()); return Action.CommitMessage; 
    } 
}); 

在Consumer启动后，其要消费的第一条消息的起始位置常用的有三种，这三种位置可以通过枚举类型 常量设置。这个枚举类型为ConsumeFromWhere。

CONSUME_FROM_LAST_OFFSET：从queue的当前最后一条消息开始消费 CONSUME_FROM_FIRST_OFFSET：从queue的第一条消息开始消费 CONSUME_FROM_TIMESTAMP：从指定的具体时间戳位置的消息开始消费。

这个具体时间戳是通过另外一个语句指定的 。 consumer.setConsumeTimestamp(“20210701080000”)  // yyyyMMddHHmmss

当消费完一批消息后，Consumer会提交其消费进度offset给Broker，Broker在收到消费进度后会将其更新到那个双层Map（ConsumerOffsetManager）及consumerOffset.json文件中，然后向该Consumer进行ACK，而ACK内容中包含三项数据：当前消费队列的最小offset（minOffset）、最大 offset（maxOffset）、及下次消费的起始offset（nextBeginOffset）。

重试队列

当rocketMQ对消息的消费出现异常时，会将发生异常的消息的offset提交到Broker中的重试队列。系统 在发生消息消费异常时会为当前的topic@group创建一个重试队列，该队列以%RETRY%开头，到达重试时间后进行消费重试。

offset的同步提交与异步提交

集群消费模式下，Consumer消费完消息后会向Broker提交消费进度offset，其提交方式分为两种： 同步提交：消费者在消费完一批消息后会向broker提交这些消息的offset，然后等待broker的成功响 应。若在等待超时之前收到了成功响应，则继续读取下一批消息进行消费（从ACK中获取 nextBeginOffset）。若没有收到响应，则会重新提交，直到获取到响应。而在这个等待过程中，消费者是阻塞的。其严重影响了消费者的吞吐量。

异步提交：消费者在消费完一批消息后向broker提交offset，但无需等待Broker的成功响应，可以继续 读取并消费下一批消息。这种方式增加了消费者的吞吐量。但需要注意，broker在收到提交的offset 后，还是会向消费者进行响应的。可能还没有收到ACK，此时Consumer会从Broker中直接获取 nextBeginOffset。

七、消费幂等

1 什么是消费幂等

当出现消费者对某条消息重复消费的情况时，重复消费的结果与消费一次的结果是相同的，并且多次消费并未对业务系统产生任何负面影响，那么这个消费过程就是消费幂等的。

幂等：若某操作执行多次与执行一次对系统产生的影响是相同的，则称该操作是幂等的

2 消息重复的场景分析

什么情况下可能会出现消息被重复消费呢？

最常见的有以下三种情况：

发送时消息重复

当一条消息已被成功发送到Broker并完成持久化，此时出现了网络闪断，从而导致Broker对Producer应答失败。 如果此时Producer意识到消息发送失败并尝试再次发送消息，此时Broker中就可能会出现两条内容相同并且Message ID也相同的消息，那么后续Consumer就一定会消费两次该消息。

消费时消息重复

消息已投递到Consumer并完成业务处理，当Consumer给Broker反馈应答时网络闪断，Broker没有接收到消费成功响应。为了保证消息至少被消费一次的原则，Broker将在网络恢复后再次尝试投递之前已被处理过的消息。此时消费者就会收到与之前处理过的内容相同、Message ID也相同的消息。

Rebalance时消息重复

当Consumer Group中的Consumer数量发生变化时，或其订阅的Topic的Queue数量发生变化时，会触 发Rebalance，此时Consumer可能会收到曾经被消费过的消息。

3 通用解决方案 两要素

幂等解决方案的设计中涉及到两项要素：幂等令牌，与唯一性处理。只要充分利用好这两要素，就可以设计出好的幂等解决方案。

幂等令牌：是生产者和消费者两者中的既定协议，通常指具备唯⼀业务标识的字符串。例如，订 单号、流水号。一般由Producer随着消息一同发送来的。

唯一性处理：服务端通过采用⼀定的算法策略，保证同⼀个业务逻辑不会被重复执行成功多次。 例如，对同一笔订单的多次支付操作，只会成功一次。

解决方案

对于常见的系统，幂等性操作的通用性解决方案是：

1. 首先通过缓存去重。在缓存中如果已经存在了某幂等令牌，则说明本次操作是重复性操作；若缓 存没有命中，则进入下一步。

2. 在唯一性处理之前，先在数据库中查询幂等令牌作为索引的数据是否存在。若存在，则说明本次 操作为重复性操作；若不存在，则进入下一步。

3. 在同一事务中完成三项操作：唯一性处理后，将幂等令牌写入到缓存，并将幂等令牌作为唯一索 引的数据写入到DB中。

        第1步已经判断过是否是重复性操作了，为什么第2步还要再次判断？能够进入第2步，说明已经 不是重复操作了，第2次判断是否重复？ 当然不重复。一般缓存中的数据是具有有效期的。缓存中数据的有效期一旦过期，就是发生缓存穿透，使请求直接就到达了DBMS。

4 消费幂等的实现

消费幂等的解决方案很简单：

为消息指定不会重复的唯一标识。因为Message ID有可能出现重复的情 况，所以真正安全的幂等处理，不建议以Message ID作为处理依据。

最好的方式是以业务唯一标识作为幂等处理的关键依据，而业务的唯一标识可以通过消息Key设置。

以支付场景为例，可以将消息的Key设置为订单号，作为幂等处理的依据。具体代码示例如下：

Message message = new Message();
message.setKey("ORDERID_100");
SendResult sendResult = producer.send(message);

消费者收到消息时可以根据消息的Key即订单号来实现消费幂等：

consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List
msgs,ConsumeConcurrentlyContext context) {
    for(MessageExt msg:msgs){
        String key = msg.getKeys();
        // 根据业务唯一标识Key做幂等处理
        // ……
    }
    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }
});

RocketMQ能够保证消息不丢失，但不能保证消息不重复。

八、消息堆积与消费延迟

1 概念

消息处理流程中，如果Consumer的消费速度跟不上Producer的发送速度，MQ中未处理的消息会越来 越多（进的多出的少），这部分消息就被称为堆积消息。消息出现堆积进而会造成消息的消费延迟。 以下场景需要重点关注消息堆积和消费延迟问题：

业务系统上下游能力不匹配造成的持续堆积，且无法自行恢复。

业务系统对消息的消费实时性要求较高，即使是短暂的堆积造成的消费延迟也无法接受。

2 产生原因分析

Consumer使用长轮询Pull模式消费消息时，分为以下两个阶段：

消息拉取

Consumer通过长轮询Pull模式批量拉取的方式从服务端获取消息，将拉取到的消息缓存到本地缓冲队列中。

对于拉取式消费，在内网环境下会有很高的吞吐量，所以这一阶段一般不会成为消息堆积的瓶颈。 一个单线程单分区的低规格主机(Consumer，4C8G)，其可达到几万的TPS。如果是多个分区多 个线程，则可以轻松达到几十万的TPS。

消息消费

Consumer将本地缓存的消息提交到消费线程中，使用业务消费逻辑对消息进行处理，处理完毕后获取到一个结果。这是真正的消息消费过程。此时Consumer的消费能力就完全依赖于消息的消费耗时和消 费并发度了。

如果由于业务处理逻辑复杂等原因，导致处理单条消息的耗时较长，则整体的消息吞吐量肯定不会高，此时就会导致Consumer本地缓冲队列达到上限，停止从服务端拉取消息。

结论

消息堆积的主要瓶颈在于客户端的消费能力，而消费能力由消费耗时和消费并发度决定。注意，消费耗时的优先级要高于消费并发度。即在保证了消费耗时的合理性前提下，再考虑消费并发度问题。

3 消费耗时

影响消息处理时长的主要因素是代码逻辑。而代码逻辑中可能会影响处理时长代码主要有两种类型： CPU内部计算型代码和外部I/O操作型代码。

通常情况下代码中如果没有复杂的递归和循环的话，内部计算耗时相对外部I/O操作来说几乎可以忽 略。所以外部IO型代码是影响消息处理时长的主要症结所在。

外部IO操作型代码举例：

读写外部数据库，例如对远程MySQL的访问

读写外部缓存系统，例如对远程Redis的访问

下游系统调用，例如Dubbo的RPC远程调用，Spring Cloud的对下游系统的Http接口调用

关于下游系统调用逻辑需要进行提前梳理，掌握每个调用操作预期的耗时，这样做是为了能够判断消费逻辑中IO操作的耗时是否合理。通常消息堆积是由于下游系统出现了服务异常或达到 了DBMS容量限制，导致消费耗时增加。

服务异常，并不仅仅是系统中出现的类似500这样的代码错误，而可能是更加隐蔽的问题。例 如，网络带宽问题。 达到了DBMS容量限制，其也会引发消息的消费耗时增加。

4 消费并发度

一般情况下，消费者端的消费并发度由单节点线程数和节点数量共同决定，其值为单节点线程数*节点 数量。不过，通常需要优先调整单节点的线程数，若单机硬件资源达到了上限，则需要通过横向扩展来提高消费并发度。

单节点线程数，即单个Consumer所包含的线程数量

节点数量，即Consumer Group所包含的Consumer数量

对于普通消息、延时消息及事务消息，并发度计算都是 单节点线程数*节点数量。

但对于顺序消息则是不同的。顺序消息的消费并发度等于 Topic的Queue分区数量。

1）全局顺序消息：该类型消息的Topic只有一个Queue分区。其可以保证该Topic的所有消息被 顺序消费。为了保证这个全局顺序性，Consumer Group中在同一时刻只能有一个Consumer的一 个线程进行消费。所以其并发度为1。

2）分区顺序消息：该类型消息的Topic有多个Queue分区。其仅可以保证该Topic的每个Queue 分区中的消息被顺序消费，不能保证整个Topic中消息的顺序消费。为了保证这个分区顺序性， 每个Queue分区中的消息在Consumer Group中的同一时刻只能有一个Consumer的一个线程进行 消费。即，在同一时刻最多会出现多个Queue分蘖有多个Consumer的多个线程并行消费。所以 其并发度为Topic的分区数量。

5 单机线程数计算

对于一台主机中线程池中线程数的设置需要谨慎，不能盲目直接调大线程数，设置过大的线程数反而会 带来大量的线程切换的开销。

理想环境下单节点的最优线程数计算模型为：C *（T1 + T2）/ T1。

C：CPU内核数 T1：CPU内部逻辑计算耗时 T2：外部IO操作耗时

最优线程数 = C *（T1 + T2）/ T1 = C * T1/T1 + C * T2/T1 = C + C * T2/T1

注意，该计算出的数值是理想状态下的理论数据，在生产环境中，不建议直接使用。而是根据 当前环境，先设置一个比该值小的数值然后观察其压测效果，然后再根据效果逐步调大线程 数，直至找到在该环境中性能最佳时的值。

6 如何避免

为了避免在业务使用时出现非预期的消息堆积和消费延迟问题，需要在前期设计阶段对整个业务逻辑进行完善的排查和梳理。其中最重要的就是梳理消息的消费耗时和设置消息消费的并发度。

梳理消息的消费耗时

通过压测获取消息的消费耗时，并对耗时较高的操作的代码逻辑进行分析。梳理消息的消费耗时需要关注以下信息： 消息消费逻辑的计算复杂度是否过高，代码是否存在无限循环和递归等缺陷。 消息消费逻辑中的I/O操作是否是必须的，能否用本地缓存等方案规避。 消费逻辑中的复杂耗时的操作是否可以做异步化处理。如果可以，是否会造成逻辑错乱。

设置消费并发度

对于消息消费并发度的计算，可以通过以下两步实施：

逐步调大单个Consumer节点的线程数，并观测节点的系统指标，得到单个节点最优的消费线程数 和消息吞吐量。

根据上下游链路的流量峰值计算出需要设置的节点数 节点数 = 流量峰值 / 单个节点消息吞吐量

九、消息的清理

消息被消费过后会被清理掉吗？不会的。 消息是被顺序存储在commitlog文件的，且消息大小不定长，所以消息的清理是不可能以消息为单位进行清理的，而是以commitlog文件为单位进行清理的。否则会急剧下降清理效率，并实现逻辑复杂。

commitlog文件存在一个过期时间，默认为72小时，即三天。除了用户手动清理外，在以下情况下也 会被自动清理，无论文件中的消息是否被消费过：

• 文件过期，且到达清理时间点（默认为凌晨4点）后，自动清理过期文件
• 文件过期，且磁盘空间占用率已达过期清理警戒线（默认75%）后，无论是否达到清理时间点， 都会自动清理过期文件
• 磁盘占用率达到清理警戒线（默认85%）后，开始按照设定好的规则清理文件，无论是否过期。 默认会从最老的文件开始清理
• 磁盘占用率达到系统危险警戒线（默认90%）后，Broker将拒绝消息写入

需要注意以下几点：

1）对于RocketMQ系统来说，删除一个1G大小的文件，是一个压力巨大的IO操作。在删除过程 中，系统性能会骤然下降。所以，其默认清理时间点为凌晨4点，访问量最小的时间。也正因如 果，我们要保障磁盘空间的空闲率，不要使系统出现在其它时间点删除commitlog文件的情况。 2）官方建议RocketMQ服务的Linux文件系统采用ext4。因为对于文件删除操作，ext4要比ext3性 能更好