SYSTEM
Broker
src/content/notes/system/Broker.md Broker
MappedFile
成员属性
MappedFile 类是最基础的存储类,继承自 ReferenceResource 类,用来保证线程安全
MappedFile 类成员变量:
-
内存相关:
public static final int OS_PAGE_SIZE = 1024 * 4;// 内存页大小:默认是 4k private AtomicLong TOTAL_MAPPED_VIRTUAL_MEMORY; // 当前进程下所有的 mappedFile 占用的总虚拟内存大小 private AtomicInteger TOTAL_MAPPED_FILES; // 当前进程下所有的 mappedFile 个数 -
数据位点:
protected final AtomicInteger wrotePosition; // 当前 mappedFile 的数据写入点 protected final AtomicInteger committedPosition;// 当前 mappedFile 的数据提交点 private final AtomicInteger flushedPosition; // 数据落盘位点,在这之前的数据是持久化的安全数据 // flushedPosition-wrotePosition 之间的数据属于脏页 -
文件相关:CL 是 CommitLog,CQ 是 ConsumeQueue
private String fileName; // 文件名称,CL和CQ文件名是【第一条消息的物理偏移量】,索引文件是【年月日时分秒】 private long fileFromOffset;// 文件名转long,代表该对象的【起始偏移量】 private File file; // 文件对象MF 中以物理偏移量作为文件名,可以更好的寻址和进行判断
-
内存映射:
protected FileChannel fileChannel; // 文件通道 private MappedByteBuffer mappedByteBuffer; // 内存映射缓冲区,访问虚拟内存
ReferenceResource 类成员变量:
-
引用数量:当
refCount <= 0时,表示该资源可以释放了,没有任何其他程序依赖它了,用原子类保证线程安全protected final AtomicLong refCount = new AtomicLong(1); // 初始值为 1 -
存活状态:表示资源的存活状态
protected volatile boolean available = true; -
是否清理:默认值 false,当执行完子类对象的 cleanup() 清理方法后,该值置为 true ,表示资源已经全部释放
protected volatile boolean cleanupOver = false; -
第一次关闭资源的时间:用来记录超时时间
private volatile long firstShutdownTimestamp = 0;
成员方法
MappedFile 类核心方法:
-
appendMessage():提供上层向内存映射中追加消息的方法,消息如何追加由 AppendMessageCallback 控制
// 参数一:消息 参数二:追加消息回调 public AppendMessageResult appendMessage(MessageExtBrokerInner msg, AppendMessageCallback cb)// 将字节数组写入到文件通道 public boolean appendMessage(final byte[] data) -
flush():刷盘接口,参数 flushLeastPages 代表刷盘的最小页数 ,等于 0 时属于强制刷盘;> 0 时需要脏页(计算方法在数据位点)达到该值才进行物理刷盘;文件写满时强制刷盘
public int flush(final int flushLeastPages) -
selectMappedBuffer():该方法以 pos 为开始位点 ,到有效数据为止,创建一个切片 ByteBuffer 作为数据副本,供业务访问数据
public SelectMappedBufferResult selectMappedBuffer(int pos) -
destroy():销毁映射文件对象,并删除关联的系统文件,参数是强制关闭资源的时间
public boolean destroy(final long intervalForcibly) -
cleanup():释放堆外内存,更新总虚拟内存和总内存映射文件数
public boolean cleanup(final long currentRef) -
warmMappedFile():内存预热,当要新建的 MappedFile 对象大于 1g 时执行该方法。mappedByteBuffer 已经通过mmap映射,此时操作系统中只是记录了该文件和该 Buffer 的映射关系,而并没有映射到物理内存中,对该 MappedFile 的每个 Page Cache 进行写入一个字节分配内存,将映射文件全部加载到内存
public void warmMappedFile(FlushDiskType type, int pages) -
mlock():锁住指定的内存区域避免被操作系统调到 swap 空间,减少了缺页异常的产生
public void mlock()swap space 是磁盘上的一块区域,可以是一个分区或者一个文件或者是组合。当系统物理内存不足时,Linux 会将内存中不常访问的数据保存到 swap 区域上,这样系统就可以有更多的物理内存为各个进程服务,而当系统需要访问 swap 上存储的内容时,需要通过缺页中断将 swap 上的数据加载到内存中
ReferenceResource 类核心方法:
-
hold():增加引用记数 refCount,方法加锁
public synchronized boolean hold() -
shutdown():关闭资源,参数代表强制关闭资源的时间间隔
// 系统当前时间 - firstShutdownTimestamp 时间 > intervalForcibly 进行【强制关闭】 public void shutdown(final long intervalForcibly) -
release():引用计数减 1,当 refCount 为 0 时,调用子类的 cleanup 方法
public void release()
MapQueue
成员属性
MappedFileQueue 用来管理 MappedFile 文件
成员变量:
-
管理目录:CommitLog 是
../store/commitlog, ConsumeQueue 是../store/xxx_topic/0private final String storePath; -
文件属性:
private final int mappedFileSize; // 目录下每个文件大小,CL文件默认 1g,CQ文件 默认 600w字节 private final CopyOnWriteArrayList<MappedFile> mappedFiles; //目录下的每个 mappedFile 都加入该集合 -
数据位点:
private long flushedWhere = 0; // 目录的刷盘位点,值为 mf.fileName + mf.wrotePosition private long committedWhere = 0; // 目录的提交位点 -
消息存储:
private volatile long storeTimestamp = 0; // 当前目录下最后一条 msg 的存储时间 -
创建服务:新建 MappedFile 实例,继承自 ServiceThread 是一个任务对象,run 方法用来创建实例
private final AllocateMappedFileService allocateMappedFileService;
成员方法
核心方法:
-
load():Broker 启动时,加载本地磁盘数据,该方法读取 storePath 目录下的文件,创建 MappedFile 对象放入集合内
public boolean load() -
getLastMappedFile():获取当前正在顺序写入的 MappedFile 对象,如果最后一个 MappedFile 写满了,或者不存在 MappedFile 对象,则创建新的 MappedFile
// 参数一:文件起始偏移量;参数二:当list为空时,是否新建 MappedFile public MappedFile getLastMappedFile(final long startOffset, boolean needCreate) -
flush():根据 flushedWhere 属性查找合适的 MappedFile,调用该 MappedFile 的落盘方法,并更新全局的 flushedWhere
//参数:0 表示强制刷新, > 0 脏页数据必须达到 flushLeastPages 才刷新 public boolean flush(final int flushLeastPages) -
findMappedFileByOffset():根据偏移量查询对象
public MappedFile findMappedFileByOffset(final long offset, final boolean returnFirstOnNotFound) -
deleteExpiredFileByTime():CL 删除过期文件,根据文件的保留时长决定是否删除
// 参数一:过期时间; 参数二:删除两个文件之间的时间间隔; 参数三:mf.destory传递的参数; 参数四:true 强制删除 public int deleteExpiredFileByTime(final long expiredTime,final int deleteFilesInterval, final long intervalForcibly, final boolean cleanImmediately) -
deleteExpiredFileByOffset():CQ 删除过期文件,遍历每个 MF 文件,获取当前文件最后一个数据单元的物理偏移量,小于 offset 说明当前 MF 文件内都是过期数据
// 参数一:consumeLog 目录下最小物理偏移量,就是第一条消息的 offset; // 参数二:ConsumerQueue 文件内每个数据单元固定大小 public int deleteExpiredFileByOffset(long offset, int unitSize)
CommitLog
成员属性
成员变量:
-
魔数:
public final static int MESSAGE_MAGIC_CODE = -626843481; // 消息的第一个字段是大小,第二个字段就是魔数 protected final static int BLANK_MAGIC_CODE = -875286124; // 文件尾消息的魔法值 -
MappedFileQueue:用于管理
../store/commitlog目录下的文件protected final MappedFileQueue mappedFileQueue; -
存储服务:
protected final DefaultMessageStore defaultMessageStore; // 存储模块对象,上层服务 private final FlushCommitLogService flushCommitLogService; // 刷盘服务,默认实现是异步刷盘 -
回调器:控制消息的哪些字段添加到 MappedFile
private final AppendMessageCallback appendMessageCallback; -
队列偏移量字典表:key 是主题队列 id,value 是偏移量
protected HashMap<String, Long> topicQueueTable = new HashMap<String, Long>(1024); -
锁相关:
private volatile long beginTimeInLock = 0; // 写数据时加锁的开始时间 protected final PutMessageLock putMessageLock; // 写锁,两个实现类:自旋锁和重入锁因为发送消息是需要持久化的,在 Broker 端持久化时会获取该锁,保证发送的消息的线程安全
构造方法:
-
有参构造:
public CommitLog(final DefaultMessageStore defaultMessageStore) { // 创建 MappedFileQueue 对象 // 参数1:../store/commitlog; 参数2:【1g】; 参数3:allocateMappedFileService this.mappedFileQueue = new MappedFileQueue(...); // 默认 异步刷盘,创建这个对象 this.flushCommitLogService = new FlushRealTimeService(); // 控制消息哪些字段追加到 mappedFile,【消息最大是 4M】 this.appendMessageCallback = new DefaultAppendMessageCallback(...); // 默认使用自旋锁 this.putMessageLock = ...; }
成员方法
CommitLog 类核心方法:
-
start():会启动刷盘服务
public void start() -
shutdown():关闭刷盘服务
public void shutdown() -
load():加载 CommitLog 目录下的文件
public boolean load() -
getMessage():根据 offset 查询单条信息,返回的结果对象内部封装了一个 ByteBuffer,该 Buffer 表示
[offset, offset + size]区间的 MappedFile 的数据public SelectMappedBufferResult getMessage(final long offset, final int size) -
deleteExpiredFile():删除过期文件,方法由 DefaultMessageStore 的定时任务调用
public int deleteExpiredFile() -
asyncPutMessage():存储消息
public CompletableFuture<PutMessageResult> asyncPutMessage(final MessageExtBrokerInner msg)msg.setStoreTimestamp(System.currentTimeMillis()):设置存储时间,后面获取到写锁后这个事件会重写msg.setBodyCRC(UtilAll.crc32(msg.getBody())):获取消息的 CRC 值topic、queueId:获取主题和队列 IDif (msg.getDelayTimeLevel() > 0):获取消息的延迟级别,这里是延迟消息实现的关键topic = TopicValidator.RMQ_SYS_SCHEDULE_TOPIC:修改消息的主题为SCHEDULE_TOPIC_XXXXqueueId = ScheduleMessageService.delayLevel2QueueId():队列 ID 为延迟级别 -1MessageAccessor.putProperty:将原来的消息主题和 ID 存入消息的属性REAL_TOPIC中mappedFile = this.mappedFileQueue.getLastMappedFile():获取当前顺序写的 MappedFile 对象putMessageLock.lock():获取写锁msg.setStoreTimestamp(beginLockTimestamp):设置消息的存储时间为获取锁的时间if (null == mappedFile || mappedFile.isFull()):文件写满了创建新的 MF 对象result = mappedFile.appendMessage(msg, this.appendMessageCallback):消息追加,核心逻辑在回调器类putMessageLock.unlock():释放写锁this.defaultMessageStore.unlockMappedFile(..):将 MappedByteBuffer 从 lock 切换为 unlock 状态putMessageResult = new PutMessageResult(PutMessageStatus.PUT_OK, result):结果封装flushResultFuture = submitFlushRequest(result, msg):唤醒刷盘线程replicaResultFuture = submitReplicaRequest(result, msg):HA 消息同步
-
recoverNormally():正常关机时的恢复方法,存储模块启动时先恢复所有的 ConsumeQueue 数据,再恢复 CommitLog 数据
// 参数表示恢复阶段 ConsumeQueue 中已知的最大的消息 offset public void recoverNormally(long maxPhyOffsetOfConsumeQueue)-
int index = mappedFiles.size() - 3:从倒数第三个 file 开始向后恢复 -
dispatchRequest = this.checkMessageAndReturnSize():每次从切片内解析出一条 msg 封装成 DispatchRequest 对象 -
size = dispatchRequest.getMsgSize():获取消息的大小,检查 DispatchRequest 对象的状态情况 1:正常数据,则
mappedFileOffset += size情况 2:文件尾数据,处理下一个文件,mappedFileOffset 置为 0,magic_code 表示文件尾
-
processOffset += mappedFileOffset:计算出正确的数据存储位点,并设置 MappedFileQueue 的目录刷盘位点 -
this.mappedFileQueue.truncateDirtyFiles(processOffset):调整 MFQ 中文件的刷盘位点 -
if (maxPhyOffsetOfConsumeQueue >= processOffset):删除冗余数据,将超过全局位点的 CQ 下的文件删除,将包含全局位点的 CQ 下的文件重新定位
-
-
recoverAbnormally():异常关机时的恢复方法
public void recoverAbnormally(long maxPhyOffsetOfConsumeQueue)int index = mappedFiles.size() - 1:从尾部开始遍历 MFQ,验证 MF 的第一条消息,找到第一个验证通过的文件对象dispatchRequest = this.checkMessageAndReturnSize():每次解析出一条 msg 封装成 DispatchRequest 对象this.defaultMessageStore.doDispatch(dispatchRequest):重建 ConsumerQueue 和 Index,避免上次异常停机导致 CQ 和 Index 与 CommitLog 不对齐- 剩余逻辑与正常关机的恢复方法相似
服务线程
AppendMessageCallback 消息追加服务实现类为 DefaultAppendMessageCallback
-
doAppend():
public AppendMessageResult doAppend()long wroteOffset = fileFromOffset + byteBuffer.position():消息写入的位置,物理偏移量 phyOffsetString msgId:消息 ID,规则是客户端 IP + 消息偏移量 phyOffsetbyte[] topicData:序列化消息,将消息的字段压入到 msgStoreItemMemory 这个 Buffer 中byteBuffer.put(this.msgStoreItemMemory.array(), 0, msgLen):将 msgStoreItemMemory 中的数据写入 MF 对象的内存映射的 Buffer 中,数据还没落盘AppendMessageResult result:构造结果对象,包括存储位点、是否成功、队列偏移量等信息CommitLog.this.topicQueueTable.put(key, ++queueOffset):更新队列偏移量
FlushRealTimeService 刷盘 CL 数据,默认是异步刷盘类 FlushRealTimeService
-
run():运行方法
public void run()-
while (!this.isStopped()):stopped为 true 才跳出循环 -
boolean flushCommitLogTimed:控制线程的休眠方式,默认是 false,使用CountDownLatch.await()休眠,设置为 true 时使用Thread.sleep()休眠 -
int interval:获取配置中的刷盘时间间隔 -
int flushPhysicQueueLeastPages:获取最小刷盘页数,默认是 4 页,脏页达到指定页数才刷盘 -
int flushPhysicQueueThoroughInterval:获取强制刷盘周期,默认是 10 秒,达到周期后强制刷盘,不考虑脏页 -
if (flushCommitLogTimed):休眠逻辑,避免 CPU 占用太长时间,导致无法执行其他更紧急的任务 -
CommitLog.this.mappedFileQueue.flush(flushPhysicQueueLeastPages):刷盘 -
for (int i = 0; i < RETRY_TIMES_OVER && !result; i++):stopped 停止标记为 true 时,需要确保所有的数据都已经刷盘,所以此处尝试 10 次强制刷盘,result = CommitLog.this.mappedFileQueue.flush(0):强制刷盘
-
同步刷盘类 GroupCommitService
-
run():运行方法
public void run()-
while (!this.isStopped()):stopped为 true 才跳出循环this.waitForRunning(10):线程休眠 10 毫秒,最后调用onWaitEnd()进行请求的交换swapRequests()this.doCommit():做提交逻辑-
if (!this.requestsRead.isEmpty()):读请求集合不为空for (GroupCommitRequest req : this.requestsRead):遍历所有的读请求,请求中的属性:private final long nextOffset:本条消息存储之后,下一条消息开始的 offsetprivate CompletableFuture<PutMessageStatus> flushOKFuture:Future 对象
boolean flushOK = ...:当前请求关注的数据是否全部落盘,落盘成功唤醒消费者线程for (int i = 0; i < 2 && !flushOK; i++):尝试进行两次强制刷盘,保证刷盘成功CommitLog.this.mappedFileQueue.flush(0):强制刷盘req.wakeupCustomer(flushOK ? ...):设置 Future 结果,在 Future 阻塞的线程在这里会被唤醒this.requestsRead.clear():清理 reqeustsRead 列表,方便交换时成为 requestsWrite 使用 -
else:读请求集合为空CommitLog.this.mappedFileQueue.flush(0):强制刷盘
-
-
this.swapRequests():交换读写请求 -
this.doCommit():交换后做一次提交
-
ConsQueue
成员属性
ConsumerQueue 是消息消费队列,存储消息在 CommitLog 的索引,便于快速定位消息
成员变量:
-
数据单元:ConsumerQueueData 数据单元的固定大小是 20 字节,默认申请 20 字节的缓冲区
public static final int CQ_STORE_UNIT_SIZE = 20; -
文件管理:
private final MappedFileQueue mappedFileQueue; // 文件管理器,管理 CQ 目录下的文件 private final String storePath; // 目录,比如../store/consumequeue/xxx_topic/0 private final int mappedFileSize; // 每一个 CQ 存储文件大小,默认 20 * 30w = 600w byte -
存储主模块:上层的对象
private final DefaultMessageStore defaultMessageStore; -
消息属性:
private final String topic; // CQ 主题 private final int queueId; // CQ 队列,每一个队列都有一个 ConsumeQueue 对象进行管理 private final ByteBuffer byteBufferIndex; // 临时缓冲区,插新的 CQData 时使用 private long maxPhysicOffset = -1; // 当前ConsumeQueue内存储的最大消息物理偏移量 private volatile long minLogicOffset = 0; // 当前ConsumeQueue内存储的最小消息物理偏移量
构造方法:
-
有参构造:
public ConsumeQueue() { // 申请了一个 20 字节大小的 临时缓冲区 this.byteBufferIndex = ByteBuffer.allocate(CQ_STORE_UNIT_SIZE); }
成员方法
ConsumeQueue 启动阶段方法:
- load():第一步,加载 storePath 目录下的文件,初始化 MappedFileQueue
- recover():第二步,恢复 ConsumeQueue 数据
- 从倒数第三个 MF 文件开始向后遍历,依次读取 MF 中 20 个字节的 CQData 数据,检查 offset 和 size 是否是有效数据
- 找到无效的 CQData 的位点,该位点就是 CQ 的刷盘点和数据顺序写入点
- 删除无效的 MF 文件,调整当前顺序写的 MF 文件的数据位点
其他方法:
-
truncateDirtyLogicFiles():CommitLog 恢复阶段调用,将 ConsumeQueue 有效数据文件与 CommitLog 对齐,将超出部分的数据文删除掉,并调整当前文件的数据位点。Broker 启动阶段先恢复 CQ 的数据,再恢复 CL 数据,但是数据要以 CL 为基准
// 参数是最大消息物理偏移量 public void truncateDirtyLogicFiles(long phyOffet) -
flush():刷盘,调用 MFQ 的刷盘方法
public boolean flush(final int flushLeastPages) -
deleteExpiredFile():删除过期文件,将小于 offset 的所有 MF 文件删除,offset 是 CommitLog 目录下最小的物理偏移量,小于该值的 CL 文件已经没有了,所以 CQ 也没有存在的必要
public int deleteExpiredFile(long offset) -
putMessagePositionInfoWrapper():向 CQ 中追加 CQData 数据,由存储主模块 DefaultMessageStore 内部的异步线程调用,负责构建 ConsumeQueue 文件和 Index 文件的,该线程会持续关注 CommitLog 文件,当 CommitLog 文件内有新数据写入,就读出来封装成 DispatchRequest 对象,转发给 ConsumeQueue 或者 IndexService
public void putMessagePositionInfoWrapper(DispatchRequest request) -
getIndexBuffer():转换 startIndex 为 offset,获取包含该 offset 的 MappedFile 文件,读取
[offset%maxSize, mfPos]范围的数据,包装成结果对象返回public SelectMappedBufferResult getIndexBuffer(final long startIndex)
IndexFile
成员属性
IndexFile 类成员属性
-
哈希:
private static int hashSlotSize = 4; // 每个 hash 桶的大小是 4 字节,【用来存放索引的编号】 private final int hashSlotNum; // hash 桶的个数,默认 500 万 -
索引:
private static int indexSize = 20; // 每个 index 条目的大小是 20 字节 private static int invalidIndex = 0; // 无效索引编号:0 特殊值 private final int indexNum; // 默认值:2000w private final IndexHeader indexHeader; // 索引头 -
映射:
private final MappedFile mappedFile; // 【索引文件使用的 MF 文件】 private final FileChannel fileChannel; // 文件通道 private final MappedByteBuffer mappedByteBuffer;// 从 MF 中获取的内存映射缓冲区
构造方法:
-
有参构造
// endPhyOffset 上个索引文件 最后一条消息的 物理偏移量 // endTimestamp 上个索引文件 最后一条消息的 存储时间 public IndexFile(final String fileName, final int hashSlotNum, final int indexNum, final long endPhyOffset, final long endTimestamp) throws IOException { // 文件大小 40 + 500w * 4 + 2000w * 20 int fileTotalSize = IndexHeader.INDEX_HEADER_SIZE + (hashSlotNum * hashSlotSize) + (indexNum * indexSize); // 创建 mf 对象,会在disk上创建文件 this.mappedFile = new MappedFile(fileName, fileTotalSize); // 创建 索引头对象,传递 索引文件mf 的切片数据 this.indexHeader = new IndexHeader(byteBuffer); //... }
成员方法
IndexFile 类方法
-
load():加载 IndexHeader
public void load() -
flush():MappedByteBuffer 内的数据强制落盘
public void flush() -
isWriteFull():检查当前的 IndexFile 已写索引数是否 >= indexNum,达到该值则当前 IndexFile 不能继续追加 IndexData 了
public boolean isWriteFull() -
destroy():删除文件时使用的方法
public boolean destroy(final long intervalForcibly) -
putKey():添加索引数据,解决哈希冲突使用头插法
// 参数一:消息的 key,uniq_key 或者 keys="aaa bbb ccc" 会分别为 aaa bbb ccc 创建索引 // 参数二:消息的物理偏移量; 参数三:消息存储时间 public boolean putKey(final String key, final long phyOffset, final long storeTimestamp)int slotPos = keyHash % this.hashSlotNum:对 key 计算哈希后,取模得到对应的哈希槽 slot 下标,然后计算出哈希槽的存储位置 absSlotPosint slotValue = this.mappedByteBuffer.getInt(absSlotPos):获取槽中的值,如果是无效值说明没有哈希冲突timeDiff = timeDiff / 1000:计算当前 msg 存储时间减去索引文件内第一条消息存储时间的差值,转化为秒进行存储int absIndexPos:计算当前索引数据存储的位置,开始填充索引数据到对应的位置this.mappedByteBuffer.putInt(absIndexPos + 4 + 8 + 4, slotValue):hash 桶的原值,头插法this.mappedByteBuffer.putInt(absSlotPos, this.indexHeader...):在 slot 放入当前索引的索引编号if (this.indexHeader.getIndexCount() <= 1):索引文件插入的第一条数据,需要设置起始偏移量和存储时间if (invalidIndex == slotValue):没有哈希冲突,说明占用了一个新的 hash slotthis.indexHeader:设置索引头的相关属性
-
selectPhyOffset():从索引文件查询消息的物理偏移量
// 参数一:查询结果全部放到该list内; 参数二:查询key; 参数三:结果最大数限制; 参数四五:时间范围 public void selectPhyOffset(final List<Long> phyOffsets, final String key, final int maxNum,final long begin, final long end, boolean lock)if (this.mappedFile.hold()): MF 的引用记数 +1,查询期间 MF 资源不能被释放int slotValue = this.mappedByteBuffer.getInt(absSlotPos):获取槽中的值,可能是无效值或者索引编号,如果是无效值说明查询未命中int absIndexPos:计算出索引编号对应索引数据的开始位点this.mappedByteBuffer:读取索引数据long timeRead = this.indexHeader.getBeginTimestamp() + timeDiff:计算出准确的存储时间boolean timeMatched = (timeRead >= begin) && (timeRead <= end):时间范围的匹配phyOffsets.add(phyOffsetRead):将命中的消息索引的消息偏移量加入到 list 集合中nextIndexToRead = prevIndexRead:遍历前驱节点
IndexServ
成员属性
IndexService 类用来管理 IndexFile 文件
成员变量:
-
存储主模块:
private final DefaultMessageStore defaultMessageStore; -
索引文件存储目录:
../store/indexprivate final String storePath; -
索引对象集合:目录下的每个文件都有一个 IndexFile 对象
private final ArrayList<IndexFile> indexFileList = new ArrayList<IndexFile>(); -
索引文件:
private final int hashSlotNum; // 每个索引文件包含的 哈希桶数量 :500w private final int indexNum; // 每个索引文件包含的 索引条目数量 :2000w
成员方法
-
load():加载 storePath 目录下的文件,为每个文件创建一个 IndexFile 实例对象,并加载 IndexHeader 信息
public boolean load(final boolean lastExitOK) -
deleteExpiredFile():删除过期索引文件
// 参数 offset 表示 CommitLog 内最早的消息的 phyOffset public void deleteExpiredFile(long offset)this.readWriteLock.readLock().lock():加锁判断long endPhyOffset = this.indexFileList.get(0).getEndPhyOffset():获取目录中第一个文件的结束偏移量if (endPhyOffset < offset):索引目录内存在过期的索引文件,并且当前的 IndexFile 都是过期的数据for (int i = 0; i < (files.length - 1); i++):遍历文件列表,删除过期的文件
-
buildIndex():存储主模块 DefaultMessageStore 内部的异步线程调用,构建 Index 数据
public void buildIndex(DispatchRequest req)-
indexFile = retryGetAndCreateIndexFile():获取或者创建顺序写的索引文件对象 -
buildKey(topic, req.getUniqKey()):构建索引 key,topic + # + uniqKey -
indexFile = putKey():插入索引文件 -
if (keys != null && keys.length() > 0):消息存在自定义索引 keysfor (int i = 0; i < keyset.length; i++):遍历每个索引,为每个 key 调用一次 putKey
-
-
getAndCreateLastIndexFile():获取当前顺序写的 IndexFile,没有就创建
public IndexFile getAndCreateLastIndexFile()
HAService
HAService
Service
HAService 类成员变量:
-
主节点属性:
// master 节点当前有多少个 slave 节点与其进行数据同步 private final AtomicInteger connectionCount = new AtomicInteger(0); // master 节点会给每个发起连接的 slave 节点的通道创建一个 HAConnection,【控制 master 端向 slave 端传输数据】 private final List<HAConnection> connectionList = new LinkedList<>(); // master 向 slave 节点推送的最大的 offset,表示数据同步的进度 private final AtomicLong push2SlaveMaxOffset = new AtomicLong(0) -
内部类属性:
// 封装了绑定服务器指定端口,监听 slave 的连接的逻辑,没有使用 Netty,使用了原生态的 NIO 去做 private final AcceptSocketService acceptSocketService; // 控制生产者线程阻塞等待的逻辑 private final GroupTransferService groupTransferService; // slave 节点的客户端对象,【slave 端才会正常运行该实例】 private final HAClient haClient; -
线程通信对象:
private final WaitNotifyObject waitNotifyObject = new WaitNotifyObject()
成员方法:
-
start():启动高可用服务
public void start() throws Exception { // 监听从节点 this.acceptSocketService.beginAccept(); // 启动监听服务 this.acceptSocketService.start(); // 启动转移服务 this.groupTransferService.start(); // 启动从节点客户端实例 this.haClient.start(); }
Accept
AcceptSocketService 类用于监听从节点的连接,创建 HAConnection 连接对象
成员变量:
-
端口信息:Master 绑定监听的端口信息
private final SocketAddress socketAddressListen; -
服务端通道:
private ServerSocketChannel serverSocketChannel; -
多路复用器:
private Selector selector;
成员方法:
-
beginAccept():开始监听连接,NIO 标准模板
public void beginAccept() -
run():服务启动
public void run()this.selector.select(1000):多路复用器阻塞获取就绪的通道,最多等待 1 秒钟Set<SelectionKey> selected = this.selector.selectedKeys():获取选择器中所有注册的通道中已经就绪好的事件for (SelectionKey k : selected):遍历所有就绪的事件if ((k.readyOps() & SelectionKey.OP_ACCEPT) != 0):说明OP_ACCEPT事件就绪SocketChannel sc = ((ServerSocketChannel) k.channel()).accept():获取到客户端连接的通道HAConnection conn = new HAConnection(HAService.this, sc):为每个连接 master 服务器的 slave 创建连接对象conn.start():启动 HAConnection 对象,内部启动两个服务为读数据服务、写数据服务HAService.this.addConnection(conn):加入到 HAConnection 集合内
Group
GroupTransferService 用来控制数据同步
成员方法:
-
doWaitTransfer():等待主从数据同步
private void doWaitTransfer()if (!this.requestsRead.isEmpty()):读请求不为空boolean transferOK = HAService.this.push2SlaveMaxOffset... >= req.getNextOffset():主从同步是否完成req.wakeupCustomer(transferOK ? ...):唤醒消费者this.requestsRead.clear():清空读请求
-
swapRequests():交换读写请求
private void swapRequests()
HAClient
成员属性
HAClient 是 slave 端运行的代码,用于和 master 服务器建立长连接,上报本地同步进度,消费服务器发来的 msg 数据
成员变量:
-
缓冲区:
private static final int READ_MAX_BUFFER_SIZE = 1024 * 1024 * 4; // 默认大小:4 MB private ByteBuffer byteBufferRead = ByteBuffer.allocate(READ_MAX_BUFFER_SIZE); private ByteBuffer byteBufferBackup = ByteBuffer.allocate(READ_MAX_BUFFER_SIZE); -
主节点地址:格式为
ip:portprivate final AtomicReference<String> masterAddress = new AtomicReference<>() -
NIO 属性:
private final ByteBuffer reportOffset; // 通信使用NIO,所以消息使用块传输,上报 slave offset 使用 private SocketChannel socketChannel; // 客户端与 master 的会话通道 private Selector selector; // 多路复用器 -
通信时间:上次会话通信时间,用于控制 socketChannel 是否关闭的
private long lastWriteTimestamp = System.currentTimeMillis(); -
进度信息:
private long currentReportedOffset = 0; // slave 当前的进度信息 private int dispatchPosition = 0; // 控制 byteBufferRead position 指针
成员方法
-
run():启动方法
public void run()-
if (this.connectMaster()):连接主节点,连接失败会休眠 5 秒String addr = this.masterAddress.get():获取 master 暴露的 HA 地址端口信息this.socketChannel = RemotingUtil.connect(socketAddress):建立连接this.socketChannel.register(this.selector, SelectionKey.OP_READ):注册到多路复用器,关注读事件this.currentReportedOffset: 初始化上报进度字段为 slave 的 maxPhyOffset
-
if (this.isTimeToReportOffset()):slave 每 5 秒会上报一次 slave 端的同步进度信息给 masterboolean result = this.reportSlaveMaxOffset():上报同步信息,上报失败关闭连接 -
this.selector.select(1000):多路复用器阻塞获取就绪的通道,最多等待 1 秒钟,获取到就绪事件或者超时后结束 -
boolean ok = this.processReadEvent():处理读事件 -
if (!reportSlaveMaxOffsetPlus()):检查是否重新上报同步进度
-
-
reportSlaveMaxOffset():上报 slave 同步进度
private boolean reportSlaveMaxOffset(final long maxOffset)-
首先向缓冲区写入 slave 端最大偏移量,写完以后切换为指定置为初始状态
-
for (int i = 0; i < 3 && this.reportOffset.hasRemaining(); i++):尝试三次写数据this.socketChannel.write(this.reportOffset):写数据 -
return !this.reportOffset.hasRemaining():写成功之后 pos = limit
-
-
processReadEvent():处理 master 发送给 slave 数据,返回 true 表示处理成功 false 表示 Socket 处于半关闭状态,需要上层重建 haClient
private boolean processReadEvent()-
int readSizeZeroTimes = 0:控制 while 循环的一个条件变量,当值为 3 时跳出循环 -
while (this.byteBufferRead.hasRemaining()):byteBufferRead 有空间可以去 Socket 读缓冲区加载数据 -
int readSize = this.socketChannel.read(this.byteBufferRead):从通道读数据 -
if (readSize > 0):加载成功,有新数据readSizeZeroTimes = 0:置为 0boolean result = this.dispatchReadRequest():处理数据的核心逻辑 -
else if (readSize == 0):连续无新数据 3 次,跳出循环 -
else:readSize = -1 就表示 Socket 处于半关闭状态,对端已经关闭了
-
-
dispatchReadRequest():处理数据的核心逻辑,master 与 slave 传输的数据格式
{[phyOffset][size][data...]},phyOffset 表示数据区间的开始偏移量,data 代表数据块,最大 32kb,可能包含多条消息的数据private boolean dispatchReadRequest()-
final int msgHeaderSize = 8 + 4:协议头大小 12 -
int readSocketPos = this.byteBufferRead.position():记录缓冲区处理数据前的 pos 位点,用于恢复指针 -
int diff = ...:当前 byteBufferRead 还剩多少 byte 未处理,每处理一条帧数据都会更新 dispatchPosition -
if (diff >= msgHeaderSize):缓冲区还有完整的协议头 header 数据 -
if (diff >= (msgHeaderSize + bodySize)):说明缓冲区内是包含当前帧的全部数据的,开始处理帧数据HAService...appendToCommitLog(masterPhyOffset, bodyData):存储数据到 CommitLog,并构建 Index 和 CQthis.byteBufferRead.position(readSocketPos):恢复 byteBufferRead 的 pos 指针this.dispatchPosition += msgHeaderSize + bodySize:加一帧数据长度,处理下一条数据使用if (!reportSlaveMaxOffsetPlus()):上报 slave 同步信息 -
if (!this.byteBufferRead.hasRemaining()):缓冲区写满了,重新分配缓冲区
-
-
reallocateByteBuffer():重新分配缓冲区
private void reallocateByteBuffer()-
int remain = READ_MAX_BUFFER_SIZE - this.dispatchPosition:表示缓冲区尚未处理过的字节数量 -
if (remain > 0):条件成立,说明缓冲区最后一帧数据是半包数据,但是不能丢失数据this.byteBufferBackup.put(this.byteBufferRead):将半包数据拷贝到 backup 缓冲区 -
this.swapByteBuffer():交换 backup 成为 read -
this.byteBufferRead.position(remain):设置 pos 为 remain ,后续加载数据 pos 从remain 开始向后移动 -
this.dispatchPosition = 0:当前缓冲区交换之后,相当于是一个全新的 byteBuffer,所以分配指针归零
-
HAConn
Connection
HAConnection 类成员变量:
-
会话通道:master 和 slave 之间通信的 SocketChannel
private final SocketChannel socketChannel; -
客户端地址:
private final String clientAddr; -
服务类:
private WriteSocketService writeSocketService; // 写数据服务 private ReadSocketService readSocketService; // 读数据服务 -
请求位点:在 slave 上报本地的进度之后被赋值,该值大于 0 后同步逻辑才会运行,master 如果不知道 slave 节点当前消息的存储进度,就无法给 slave 推送数据
private volatile long slaveRequestOffset = -1; -
应答位点: 保存最新的 slave 上报的 offset 信息,slaveAckOffset 之前的数据都可以认为 slave 已经同步完成
private volatile long slaveAckOffset = -1;
核心方法:
-
构造方法:
public HAConnection(final HAService haService, final SocketChannel socketChannel) { // 初始化一些东西 // 设置 socket 读写缓冲区为 64kb 大小 this.socketChannel.socket().setReceiveBufferSize(1024 * 64); this.socketChannel.socket().setSendBufferSize(1024 * 64); // 创建读写服务 this.writeSocketService = new WriteSocketService(this.socketChannel); this.readSocketService = new ReadSocketService(this.socketChannel); // 自增 this.haService.getConnectionCount().incrementAndGet(); } -
启动方法:
public void start() { this.readSocketService.start(); this.writeSocketService.start(); }
ReadSocket
ReadSocketService 类是一个任务对象,slave 向 master 传输的帧格式为 [long][long][long],上报的是 slave 本地的同步进度,同步进度是一个 long 值
成员变量:
-
读缓冲:
private static final int READ_MAX_BUFFER_SIZE = 1024 * 1024; // 默认大小 1MB private final ByteBuffer byteBufferRead = ByteBuffer.allocate(READ_MAX_BUFFER_SIZE); -
NIO 属性:
private final Selector selector; // 多路复用器 private final SocketChannel socketChannel; // master 与 slave 之间的会话 SocketChannel -
处理位点:缓冲区处理位点
private int processPosition = 0; -
上次读操作的时间:
private volatile long lastReadTimestamp = System.currentTimeMillis();
核心方法:
-
构造方法:
public ReadSocketService(final SocketChannel socketChannel)this.socketChannel.register(this.selector, SelectionKey.OP_READ):通道注册到多路复用器,关注读事件this.setDaemon(true):设置为守护线程
-
运行方法:
public void run()-
this.selector.select(1000):多路复用器阻塞获取就绪的通道,最多等待 1 秒钟,获取到就绪事件或者超时后结束 -
boolean ok = this.processReadEvent():读数据的核心方法,返回 true 表示处理成功 false 表示 Socket 处于半关闭状态,需要上层重建 HAConnection 对象-
int readSizeZeroTimes = 0:控制 while 循环,当连续从 Socket 读取失败 3 次(未加载到数据)跳出循环 -
if (!this.byteBufferRead.hasRemaining()):byteBufferRead 已经全部使用完,需要清理数据并更新位点 -
while (this.byteBufferRead.hasRemaining()):byteBufferRead 有空间可以去 Socket 读缓冲区加载数据 -
int readSize = this.socketChannel.read(this.byteBufferRead):从通道读数据 -
if (readSize > 0):加载成功,有新数据if ((byteBufferRead.position() - processPosition) >= 8):缓冲区的可读数据最少包含一个数据帧int pos = ...:获取可读帧数据中最后一个完整的帧数据的位点,后面的数据丢弃
-
long readOffset = ...byteBufferRead.getLong(pos - 8):读取最后一帧数据,slave 端当前的同步进度信息this.processPosition = pos:更新处理位点HAConnection.this.slaveAckOffset = readOffset:更新应答位点if (HAConnection.this.slaveRequestOffset < 0):条件成立给 slaveRequestOffset 赋值HAConnection...notifyTransferSome(slaveAckOffset):唤醒阻塞的生产者线程
-
else if (readSize == 0):读取 3 次无新数据跳出循环 -
else:readSize = -1 就表示 Socket 处于半关闭状态,对端已经关闭了
-
-
if (interval > 20):超过 20 秒未发生通信,直接结束循环
-
WriteSocket
WriteSocketService 类是一个任务对象,master 向 slave 传输的数据帧格式为 {[phyOffset][size][data...]}{[phyOffset][size][data...]}
- phyOffset:数据区间的开始偏移量,并不表示某一条具体的消息,表示的数据块开始的偏移量位置
- size:同步的数据块的大小
- data:数据块,最大 32kb,可能包含多条消息的数据
成员变量:
-
协议头:
private final int headerSize = 8 + 4; // 协议头大小:12 private final ByteBuffer byteBufferHeader; // 帧头缓冲区 -
NIO 属性:
private final Selector selector; // 多路复用器 private final SocketChannel socketChannel; // master 与 slave 之间的会话 SocketChannel -
处理位点:下一次传输同步数据的位置信息,master 给当前 slave 同步的位点
private long nextTransferFromWhere = -1; -
上次写操作:
private boolean lastWriteOver = true; // 上一轮数据是否传输完毕 private long lastWriteTimestamp = System.currentTimeMillis(); // 上次写操作的时间
核心方法:
-
构造方法:
public WriteSocketService(final SocketChannel socketChannel)this.socketChannel.register(this.selector, SelectionKey.OP_WRITE):通道注册到多路复用器,关注写事件this.setDaemon(true):设置为守护线程
-
运行方法:
public void run()-
this.selector.select(1000):多路复用器阻塞获取就绪的通道,最多等待 1 秒钟,获取到就绪事件或者超时后结束 -
if (-1 == HAConnection.this.slaveRequestOffset):等待 slave 同步完数据 -
if (-1 == this.nextTransferFromWhere):条件成立,需要初始化该变量if (0 == HAConnection.this.slaveRequestOffset):slave 是一个全新节点,从正在顺序写的 MF 开始同步数据long masterOffset = ...:获取 master 最大的 offset,并计算归属的 mappedFile 文件的开始 offsetthis.nextTransferFromWhere = masterOffset:赋值给下一次传输同步数据的位置信息this.nextTransferFromWhere = HAConnection.this.slaveRequestOffset:大部分情况走这个赋值逻辑 -
if (this.lastWriteOver):上一次待发送数据全部发送完成if (interval > 5):超过 5 秒未同步数据,发送一个 header 心跳数据包,维持长连接 -
else:上一轮的待发送数据未全部发送,需要同步数据到 slave 节点 -
SelectMappedBufferResult selectResult:到 CommitLog 中查询 nextTransferFromWhere 开始位置的数据 -
if (size > 32k):一次最多同步 32k 数据 -
this.nextTransferFromWhere += size:增加 size,下一轮传输跳过本帧数据 -
selectResult.getByteBuffer().limit(size):设置 byteBuffer 可访问数据区间为 [pos, size] -
this.selectMappedBufferResult = selectResult:待发送的数据 -
this.byteBufferHeader.put:构建帧头数据 -
this.lastWriteOver = this.transferData():处理数据,返回是否处理完成
-
-
同步方法:同步数据到 slave 节点,返回 true 表示本轮数据全部同步完成,false 表示本轮同步未完成(Header 和 Body 其中一个未同步完成都会返回 false)
private boolean transferData()-
int writeSizeZeroTimes= 0:控制 while 循环,当写失败连续 3 次时,跳出循环)跳出循环 -
while (this.byteBufferHeader.hasRemaining()):帧头数据缓冲区有待发送的数据 -
int writeSize = this.socketChannel.write(this.byteBufferHeader):向通道写帧头数据 -
if (null == this.selectMappedBufferResult):说明是心跳数据,返回心跳数据是否发送完成 -
if (!this.byteBufferHeader.hasRemaining()):Header写成功之后,才进行写 Body -
while (this.selectMappedBufferResult.getByteBuffer().hasRemaining()):数据缓冲区有待发送的数据 -
int writeSize = this.socketChannel.write(this.selectMappedBufferResult...):向通道写帧头数据 -
if (writeSize > 0):写数据成功,但是不代表 SMBR 中的数据全部写完成 -
boolean result:判断是否发送完成,返回该值
-
MesStore
生命周期
DefaultMessageStore 类核心是整个存储服务的调度类
-
构造方法:
public DefaultMessageStore()this.allocateMappedFileService.start():启动创建 MappedFile 文件服务this.indexService.start():启动索引服务
-
load():先加载 CommitLog,再加载 ConsumeQueue,最后加载 IndexFile,加载完进入恢复阶段,先恢复 CQ,在恢复 CL
public boolean load() -
start():核心启动方法
public void start()-
lock = lockFile.getChannel().tryLock(0, 1, false):获取文件锁,获取失败说明当前目录已经启动过 Broker -
long maxPhysicalPosInLogicQueue = commitLog.getMinOffset():遍历全部的 CQ 对象,获取 CQ 中消息的最大偏移量 -
this.reputMessageService.start():设置分发服务的分发位点,启动分发服务,构建 ConsumerQueue 和 IndexFile -
if (dispatchBehindBytes() <= 0):线程等待分发服务将分发数据全部处理完毕 -
this.recoverTopicQueueTable():因为修改了 CQ 数据,所以再次构建队列偏移量字段表 -
this.haService.start():启动 HA 服务 -
this.handleScheduleMessageService():启动消息调度服务 -
this.flushConsumeQueueService.start():启动 CQ 消费队列刷盘服务 -
this.commitLog.start():启动 CL 刷盘服务 -
this.storeStatsService.start():启动状态存储服务 -
this.createTempFile():创建 AbortFile,正常关机时 JVM HOOK 会删除该文件,异常宕机时该文件不会删除,开机数据恢复阶段根据是否存在该文件,执行不同的恢复策略 -
this.addScheduleTask():添加定时任务-
DefaultMessageStore.this.cleanFilesPeriodically():定时清理过期文件,周期是 10 秒this.cleanCommitLogService.run():启动清理过期的 CL 文件服务this.cleanConsumeQueueService.run():启动清理过期的 CQ 文件服务
-
DefaultMessageStore.this.checkSelf():每 10 分种进行健康检查 -
DefaultMessageStore.this.cleanCommitLogService.isSpaceFull():磁盘预警定时任务,每 10 秒一次-
if (physicRatio > this.diskSpaceWarningLevelRatio):检查磁盘是否到达 waring 阈值,默认 90%boolean diskok = ...runningFlags.getAndMakeDiskFull():设置磁盘写满标记 -
boolean diskok = ...this.runningFlags.getAndMakeDiskOK():设置磁盘可写标记
-
-
-
this.shutdown = false:刚启动,设置为 false
-
-
shutdown():关闭各种服务和线程资源,设置存储模块状态为关闭状态
public void shutdown() -
destroy():销毁 Broker 的工作目录
public void destroy()
服务线程
ServiceThread 类被很多服务继承,本身是一个 Runnable 任务对象,继承者通过重写 run 方法来实现服务的逻辑
-
run():一般实现方式
public void run() { while (!this.isStopped()) { // 业务逻辑 } }通过参数 stopped 控制服务的停止,使用 volatile 修饰保证可见性
protected volatile boolean stopped = false -
shutdown():停止线程,首先设置 stopped 为 true,然后进行唤醒,默认不直接打断线程
public void shutdown() -
waitForRunning():挂起线程,设置唤醒标记 hasNotified 为 false
protected void waitForRunning(long interval) -
wakeup():唤醒线程,设置 hasNotified 为 true
public void wakeup()
构建服务
AllocateMappedFileService 创建 MappedFile 服务
-
mmapOperation():核心服务
private boolean mmapOperation()req = this.requestQueue.take(): 从 requestQueue 阻塞队列(优先级)中获取 AllocateRequest 任务if (...isTransientStorePoolEnable()):条件成立使用直接内存写入数据, 从直接内存中 commit 到 FileChannel 中mappedFile = new MappedFile(req.getFilePath(), req.getFileSize()):根据请求的路径和大小创建对象mappedFile.warmMappedFile():判断 mappedFile 大小,只有 CommitLog 才进行文件预热req.setMappedFile(mappedFile):将创建好的 MF 对象的赋值给请求对象的成员属性req.getCountDownLatch().countDown():唤醒请求的阻塞线程
-
putRequestAndReturnMappedFile():MappedFileQueue 中用来创建 MF 对象的方法
public MappedFile putRequestAndReturnMappedFile(String nextFilePath, String nextNextFilePath, int fileSize)AllocateRequest nextReq = new AllocateRequest(...):创建 nextFilePath 的 AllocateRequest 对象,放入请求列表和阻塞队列,然后创建 nextNextFilePath 的 AllocateRequest 对象,放入请求列表和阻塞队列AllocateRequest result = this.requestTable.get(nextFilePath):从请求列表获取 nextFilePath 的请求对象result.getCountDownLatch().await(...):线程挂起,直到超时或者 nextFilePath 对应的 MF 文件创建完成return result.getMappedFile():返回创建好的 MF 文件对象
ReputMessageService 消息分发服务,用于构建 ConsumerQueue 和 IndexFile 文件
-
run():循环执行 doReput 方法,所以发送的消息存储进 CL 就可以产生对应的 CQ,每执行一次线程休眠 1 毫秒
public void run() -
doReput():实现分发的核心逻辑
private void doReput()for (boolean doNext = true; this.isCommitLogAvailable() && doNext; ):循环遍历SelectMappedBufferResult result: 从 CommitLog 拉取数据,数据范围[reputFromOffset, 包含该偏移量的 MF 的最大 Pos],封装成结果对象DispatchRequest dispatchRequest:从结果对象读取出一条 DispatchRequest 数据DefaultMessageStore.this.doDispatch(dispatchRequest):将数据交给分发器进行分发,用于构建 CQ 和索引文件this.reputFromOffset += size:更新数据范围
刷盘服务
FlushConsumeQueueService 刷盘 CQ 数据
-
run():每隔 1 秒执行一次刷盘服务,跳出循环后还会执行一次强制刷盘
public void run() -
doFlush():刷盘
private void doFlush(int retryTimes)-
int flushConsumeQueueLeastPages:脏页阈值,默认是 2 -
if (retryTimes == RETRY_TIMES_OVER):重试次数是 3 时设置强制刷盘,设置脏页阈值为 0 -
int flushConsumeQueueThoroughInterval:两次刷新的时间间隔超过 60 秒会强制刷盘 -
for (ConsumeQueue cq : maps.values()):遍历所有的 CQ,进行刷盘 -
DefaultMessageStore.this.getStoreCheckpoint().flush():强制刷盘时将 StoreCheckpoint 瞬时数据刷盘
-
FlushCommitLogService 刷盘 CL 数据,默认是异步刷盘
-
run():运行方法
public void run()-
while (!this.isStopped()):stopped为 true 才跳出循环 -
boolean flushCommitLogTimed:控制线程的休眠方式,默认是 false,使用CountDownLatch.await()休眠,设置为 true 时使用Thread.sleep()休眠 -
int interval:获取配置中的刷盘时间间隔 -
int flushPhysicQueueLeastPages:获取最小刷盘页数,默认是 4 页,脏页达到指定页数才刷盘 -
int flushPhysicQueueThoroughInterval:获取强制刷盘周期,默认是 10 秒,达到周期后强制刷盘,不考虑脏页 -
if (flushCommitLogTimed):休眠逻辑,避免 CPU 占用太长时间,导致无法执行其他更紧急的任务 -
CommitLog.this.mappedFileQueue.flush(flushPhysicQueueLeastPages):刷盘 -
for (int i = 0; i < RETRY_TIMES_OVER && !result; i++):stopped 停止标记为 true 时,需要确保所有的数据都已经刷盘,所以此处尝试 10 次强制刷盘,result = CommitLog.this.mappedFileQueue.flush(0):强制刷盘
-
清理服务
CleanCommitLogService 清理过期的 CL 数据,定时任务 10 秒调用一次,先清理 CL,再清理 CQ,因为 CQ 依赖于 CL 的数据
-
run():运行方法
public void run() -
deleteExpiredFiles():删除过期 CL 文件
private void deleteExpiredFiles()long fileReservedTime:默认 72,代表文件的保留时间boolean timeup = this.isTimeToDelete():当前时间是否是凌晨 4 点boolean spacefull = this.isSpaceToDelete():CL 或者 CQ 的目录磁盘使用率达到阈值标准 85%boolean manualDelete = this.manualDeleteFileSeveralTimes > 0:手动删除文件fileReservedTime *= 60 * 60 * 1000:默认保留 72 小时deleteCount = DefaultMessageStore.this.commitLog.deleteExpiredFile():调用 MFQ 对象的删除方法
CleanConsumeQueueService 清理过期的 CQ 数据
-
run():运行方法
public void run() -
deleteExpiredFiles():删除过期 CQ 文件
private void deleteExpiredFiles()int deleteLogicsFilesInterval:清理 CQ 的时间间隔,默认 100 毫秒long minOffset = DefaultMessageStore.this.commitLog.getMinOffset():获取 CL 文件中最小的物理偏移量if (minOffset > this.lastPhysicalMinOffset):CL 最小的偏移量大于 CQ 最小的,说明有过期数据this.lastPhysicalMinOffset = minOffset:更新 CQ 的最小偏移量for (ConsumeQueue logic : maps.values()):遍历所有的 CQ 文件logic.deleteExpiredFile(minOffset):调用 MFQ 对象的删除方法DefaultMessageStore.this.indexService.deleteExpiredFile(minOffset):删除过期的索引文件
获取消息
DefaultMessageStore#getMessage 用于获取消息,在 PullMessageProcessor#processRequest 方法中被调用 (提示:建议学习消费者源码时再阅读)
// offset: 客户端拉消息使用位点; maxMsgNums: 32; messageFilter: 一般这里是 tagCode 过滤
public GetMessageResult getMessage(final String group, final String topic, final int queueId, final long offset, final int maxMsgNums, final MessageFilter messageFilter)
-
if (this.shutdown):检查运行状态 -
GetMessageResult getResult:创建查询结果对象 -
final long maxOffsetPy = this.commitLog.getMaxOffset():获取 CommitLog 最大物理偏移量 -
ConsumeQueue consumeQueue = findConsumeQueue(topic, queueId):根据主题和队列 ID 获取 ConsumeQueue对象 -
minOffset, maxOffset:获取当前 ConsumeQueue 的最小 offset 和 最大 offset,判断是否满足本次 Pull 的 offsetif (maxOffset == 0):说明队列内无数据,设置状态为 NO_MESSAGE_IN_QUEUE,外层进行长轮询else if (offset < minOffset):说明 offset 太小了,设置状态为 OFFSET_TOO_SMALLelse if (offset == maxOffset):消费进度持平,设置状态为 OFFSET_OVERFLOW_ONE,外层进行长轮询else if (offset > maxOffset):说明 offset 越界了,设置状态为 OFFSET_OVERFLOW_BADLY -
SelectMappedBufferResult bufferConsumeQueue:查询 CQData 获取包含该 offset 的 MappedFile 文件,如果该文件不是顺序写的文件,就读取[offset%maxSize, 文件尾]范围的数据,反之读取[offset%maxSize, 文件名+wrotePosition尾]先查 CQ 的原因:因为 CQ 时 CL 的索引,通过 CQ 查询 CL 更加快捷
-
if (bufferConsumeQueue != null):只有再 CQ 删除过期数据的逻辑执行时,条件才不成立,一般都是成立的 -
long nextPhyFileStartOffset = Long.MIN_VALUE:下一个 commitLog 物理文件名,初始值为最小值 -
long maxPhyOffsetPulling = 0:本次拉消息最后一条消息的物理偏移量 -
for ():处理数据,每次处理 20 字节处理字节数大于 16000 时跳出循环 -
offsetPy, sizePy, tagsCode:读取 20 个字节后,获取消息物理偏移量、消息大小、消息 tagCode -
boolean isInDisk = checkInDiskByCommitOffset(...):检查消息是热数据还是冷数据,false 为热数据long memory:Broker 系统 40% 内存的字节数,写数据时内存不够会使用 LRU 算法淘汰数据,将淘汰数据持久化到磁盘return (maxOffsetPy - offsetPy) > memory:返回 true 说明数据已经持久化到磁盘,为冷数据
-
if (this.isTheBatchFull()):控制是否跳出循环-
if (0 == bufferTotal || 0 == messageTotal):本次 pull 消息未拉取到任何东西,需要外层 for 循环继续,返回 false -
if (maxMsgNums <= messageTotal):结果对象内消息数已经超过了最大消息数量,可以结束循环了 -
if (isInDisk):冷数据if ((bufferTotal + sizePy) > ...):冷数据一次 pull 请求最大允许获取 64kb 的消息if (messageTotal > ...):冷数据一次 pull 请求最大允许获取8 条消息 -
else:热数据if ((bufferTotal + sizePy) > ...):热数据一次 pull 请求最大允许获取 256kb 的消息if (messageTotal > ...):冷数据一次 pull 请求最大允许获取 32 条消息
-
-
if (messageFilter != null):按照消息 tagCode 进行过滤 -
selectResult = this.commitLog.getMessage(offsetPy, sizePy):根据 CQ 消息物理偏移量和消息大小到 commitLog 中查询这条 msg -
if (null == selectResult):条件成立说明 commitLog 执行了删除过期文件的定时任务,因为是先清理的 CL,所以 CQ 还有该索引数据 -
nextPhyFileStartOffset = this.commitLog.rollNextFile(offsetPy):获取包含该 offsetPy 的下一个数据文件的文件名 -
getResult.addMessage(selectResult):将本次循环查询出来的 msg 加入到 getResult 内 -
status = GetMessageStatus.FOUND:查询状态设置为 FOUND -
nextPhyFileStartOffset = Long.MIN_VALUE:设置为最小值,跳过期 CQData 数据的逻辑 -
nextBeginOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE):计算客户端下一次 pull 时使用的位点信息 -
getResult.setSuggestPullingFromSlave(diff > memory):选择主从节点的建议diff > memory => true:表示本轮查询最后一条消息为冷数据,Broker 建议客户端下一次 pull 时到 slave 节点diff > memory => false:表示本轮查询最后一条消息为热数据,Broker 建议客户端下一次 pull 时到 master 节点
-
getResult.setStatus(status):设置结果状态 -
getResult.setNextBeginOffset(nextBeginOffset):设置客户端下一次 pull 时的 offset -
getResult.setMaxOffset(maxOffset):设置 queue 的最大 offset 和最小 offset -
return getResult:返回结果对象
Broker
BrokerStartup 启动方法
public static void main(String[] args) {
start(createBrokerController(args));
}
public static BrokerController start(BrokerController controller) {
controller.start(); // 启动
}
BrokerStartup#createBrokerController:构造控制器,并初始化
final BrokerController controller():创建实例对象boolean initResult = controller.initialize():控制器初始化this.registerProcessor():注册了处理器,包括发送消息、拉取消息、查询消息等核心处理器initialTransaction():初始化了事务服务,用于进行事务回查
BrokerController#start:核心启动方法
-
this.messageStore.start():启动存储服务 -
this.remotingServer.start():启动 Netty 通信服务 -
this.fileWatchService.start():启动文件监听服务 -
startProcessorByHa(messageStoreConfig.getBrokerRole()):启动事务回查 -
this.scheduledExecutorService.scheduleAtFixedRate():每隔 30s 向 NameServer 上报 Topic 路由信息,心跳机制BrokerController.this.registerBrokerAll(true, false, brokerConfig.isForceRegister())