ROCKETMQ key索引的插入查询原理

最新推荐文章于 2024-04-27 16:08:55 发布
最新推荐文章于 2024-04-27 16:08:55 发布
阅读量1.9k 收藏
点赞数
文章标签： 数据结构与算法 python
原文链接：https://my.oschina.net/liangxiao/blog/3054702
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

摘要

插入逻辑

  • 1、计算key的hash值
  • 2、根据hash值找到对应的slot，slot的内容是这个hash上一个（想对当前key来说的）index的逻辑位置（第几个）
  • 3、计算当前key应该存放到index 的物理位置（header部分的固定长度，加上slot部分的固定数目*slot的单个固定长度，加上 index的固定长度 * 当前index的数据，写入key对应的index
  • 4、更新slot的内容为当前index的个数

读取逻辑

  • 1、计算hash值，找到slot，取出slot的value，这个value就是这个hash的最近的一个index（key对应的）
  • 2、逐个向前迭代，key的hash值一致、且时间符合，则取出来

文件结构

index数据结构

index的数据结构总共包括header，slot，index总计3个部分组成，各个部分的格式如下图所示，其中slot可以保存500万slot，index部分可以保存2000万index。

header 部分好理解，就是一些基本信息。 slot 部分存储的是 key的hash值%500w（假设这个值叫 keyHashM值），这种值最后一个key在index部分的逻辑位置（第几个），因为index里面每一个单元信息包含同keyHashM值的上一个key的逻辑位置，这样，查找的时候倒叙查找就可以了。 index 部分存储的就是消息的物理位置，还有一个关键信息，是keyHashM值的上一个在index里面的逻辑位置

header数据结构

  •  1. beginTimestamp : 该索引文件的第一个消息(Message)的存储时间(落盘时间) 物理位置(pos: 0-7) 8bytes   
    1. endTimestamp : 该索引文件的最后一个消息(Message)的存储时间(落盘时间) 物理位置(pos: 8-15) 8bytes   
    1. beginPhyoffset : 该索引文件第一个消息(Message)的在CommitLog(消息存储文件)的物理位置偏移量(可以通过该物理偏移直接获取到该消息) 物理位置(pos: 16-23) 8bytes    
    1. beginPhyoffset : 该索引文件最后一个消息(Message)的在CommitLog(消息存储文件)的物理位置偏移量 (pos: 24-31) 8bytes   
    1. hashSlotCount : 该索引文件目前的hash slot的个数 (pos: 32-35) 4bytes    
    1. indexCount : 该索引文件目前的索引个数 (pos: 36-39) 4bytes

slot的单元结构

slot的每一个单元信息，存储的是这种值（key的hash值 % 500W），最近的一个（也可以说是最后一个）key在index部分的逻辑位置（第几个），这样插入的时候方便直接知道要插入的key上一个的位置，查询的时候知道这种值的key的最后一个的位置。

index的单元结构

    1. key hash value: message key的hash值   
    1. phyOffset: message在CommitLog的物理文件地址, 可以直接查询到该消息(索引的核心机制)    
    1. timeDiff: message的落盘时间与header里的beginTimestamp的差值(为了节省存储空间，如果直接存message的落盘时间就得8bytes)    
    1. prevIndex: hash冲突处理的关键之处, 相同hash值上一个消息索引的index(如果当前消息索引是该hash值的第一个索引，则prevIndex=0, 也是消息索引查找时的停止条件)，每个slot位置的第一个消息的prevIndex就是0的。

源码

org.apache.rocketmq.store.index.IndexFile

插入源码

/**
     * 存储key
     * 步骤：1、计算key的hash值
     *     2、根据hash值找到对应的slot，slot的内容是这个hash上一个（想对当前key来说的）index的逻辑位置（第几个）
     *     3、计算当前key应该存放到index 的物理位置（header部分的固定长度，加上slot部分的固定数目*slot的单个固定长度，加上 index的固定长度 * 当前index的数据，写入key对应的index
     *     4、更新slot的内容为当前index的个数
     * @param key
     * @param phyOffset
     * @param storeTimestamp
     * @return
     */
    public boolean putKey(final String key, final long phyOffset, final long storeTimestamp) {
    	//1. 判断该索引文件的索引数小于最大的索引数，如果>=最大索引数，IndexService就会尝试新建一个索引文件
        if (this.indexHeader.getIndexCount() < this.indexNum) {
        	//计算当前消息key的hash值
            int keyHash = indexKeyHashMethod(key);
            // 计算出 slot的位置
            int slotPos = keyHash % this.hashSlotNum;
            int absSlotPos = IndexHeader.INDEX_HEADER_SIZE + slotPos * hashSlotSize;

            FileLock fileLock = null;

            try {

                // fileLock = this.fileChannel.lock(absSlotPos, hashSlotSize,
                // false);
            	//这里存的是逻辑位置，第几个索引
                int slotValue = this.mappedByteBuffer.getInt(absSlotPos);// slot固定的4字节长度
                if (slotValue <= invalidIndex || slotValue > this.indexHeader.getIndexCount()) {
                    slotValue = invalidIndex;
                }

                long timeDiff = storeTimestamp - this.indexHeader.getBeginTimestamp();

                timeDiff = timeDiff / 1000;

                if (this.indexHeader.getBeginTimestamp() <= 0) {
                    timeDiff = 0;
                } else if (timeDiff > Integer.MAX_VALUE) {
                    timeDiff = Integer.MAX_VALUE;
                } else if (timeDiff < 0) {
                    timeDiff = 0;
                }
                //计算当前索引应该放的位置
                int absIndexPos =
                    IndexHeader.INDEX_HEADER_SIZE + this.hashSlotNum * hashSlotSize
                        + this.indexHeader.getIndexCount() * indexSize;

                /**
                 * 4字节  存的 key的hash值
                 * 8字节  存的是消息的物理地址  在commitlog上的物理地址
                 * 4字节  相对于当前文件的时间偏差
                 * 4字节   同hash值上一个索引的逻辑偏移值
                 */
                this.mappedByteBuffer.putInt(absIndexPos, keyHash);// 
                this.mappedByteBuffer.putLong(absIndexPos + 4, phyOffset);
                this.mappedByteBuffer.putInt(absIndexPos + 4 + 8, (int) timeDiff);
                this.mappedByteBuffer.putInt(absIndexPos + 4 + 8 + 4, slotValue);
                
                //更新slotValue ， 将当前是第几个索引，更新到这个slotValue的内容中
                this.mappedByteBuffer.putInt(absSlotPos, this.indexHeader.getIndexCount());

                if (this.indexHeader.getIndexCount() <= 1) {
                    this.indexHeader.setBeginPhyOffset(phyOffset);
                    this.indexHeader.setBeginTimestamp(storeTimestamp);
                }

                this.indexHeader.incHashSlotCount();
                this.indexHeader.incIndexCount();
                this.indexHeader.setEndPhyOffset(phyOffset);
                this.indexHeader.setEndTimestamp(storeTimestamp);

                return true;
            } catch (Exception e) {
                log.error("putKey exception, Key: " + key + " KeyHashCode: " + key.hashCode(), e);
            } finally {
                if (fileLock != null) {
                    try {
                        fileLock.release();
                    } catch (IOException e) {
                        log.error("Failed to release the lock", e);
                    }
                }
            }
        } else {
            log.warn("Over index file capacity: index count = " + this.indexHeader.getIndexCount()
                + "; index max num = " + this.indexNum);
        }

        return false;
    }

查询源码

/**
     * 根据key查询消息
     * 1、计算hash值，找到slot，取出slot的value，这个value就是这个hash的最近的一个index（key对应的）
     * 2、逐个向前迭代，key的hash值一致、且时间符合，则取出来
     * @param phyOffsets
     * @param key
     * @param maxNum
     * @param begin
     * @param end
     * @param lock
     */
    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()) {
            int keyHash = indexKeyHashMethod(key);
            int slotPos = keyHash % this.hashSlotNum;
            int absSlotPos = IndexHeader.INDEX_HEADER_SIZE + slotPos * hashSlotSize;

            FileLock fileLock = null;
            try {
                if (lock) {
                    // fileLock = this.fileChannel.lock(absSlotPos,
                    // hashSlotSize, true);
                }

                int slotValue = this.mappedByteBuffer.getInt(absSlotPos);
                // if (fileLock != null) {
                // fileLock.release();
                // fileLock = null;
                // }

                if (slotValue <= invalidIndex || slotValue > this.indexHeader.getIndexCount()
                    || this.indexHeader.getIndexCount() <= 1) {
                } else {
                    for (int nextIndexToRead = slotValue; ; ) {
                        if (phyOffsets.size() >= maxNum) {
                            break;
                        }
                        // 计算当前nextIndexToRead的物理位置
                        int absIndexPos =
                            IndexHeader.INDEX_HEADER_SIZE + this.hashSlotNum * hashSlotSize
                                + nextIndexToRead * indexSize;
                        //
                        int keyHashRead = this.mappedByteBuffer.getInt(absIndexPos);
                        long phyOffsetRead = this.mappedByteBuffer.getLong(absIndexPos + 4);

                        long timeDiff = (long) this.mappedByteBuffer.getInt(absIndexPos + 4 + 8);
                        int prevIndexRead = this.mappedByteBuffer.getInt(absIndexPos + 4 + 8 + 4);

                        if (timeDiff < 0) {
                            break;
                        }

                        timeDiff *= 1000L;

                        long timeRead = this.indexHeader.getBeginTimestamp() + timeDiff;
                        boolean timeMatched = (timeRead >= begin) && (timeRead <= end);

                        // index里面的keyHashRead 跟传进来的 keyHash值相等，且时间对的上，则认为是相同的
                        if (keyHash == keyHashRead && timeMatched) {
                            phyOffsets.add(phyOffsetRead);
                        }

                        if (prevIndexRead <= invalidIndex
                            || prevIndexRead > this.indexHeader.getIndexCount()
                            || prevIndexRead == nextIndexToRead || timeRead < begin) {
                            break;
                        }

                        nextIndexToRead = prevIndexRead;
                    }
                }
            } catch (Exception e) {
                log.error("selectPhyOffset exception ", e);
            } finally {
                if (fileLock != null) {
                    try {
                        fileLock.release();
                    } catch (IOException e) {
                        log.error("Failed to release the lock", e);
                    }
                }

                this.mappedFile.release();
            }
        }
    }

参考文档

rocketMq - index介绍

RocketMQ源码分析（一）： 索引文件(IndexFile)

转载于:https://my.oschina.net/liangxiao/blog/3054702

weixin_34294649
关注
Rocketmq
QQ418579986的博客
08-29 613
实战总结
rocketmq消息索引是怎么做的
qq_35362055的博客
06-06 480
rocketmq消息索引是怎么做的 参考文章 形象的图示举例很棒：https://kunzhao.org/docs/rocketmq/rocketmq-message-indexing-flow 写简单代码解析rocketmq的消息索引文件：https://juejin.im/post/5eaa6add6fb9a04359028457 在使用rmq的过程中觉得他的消息检索很方便，像一个db一样，很好奇它在数据量这么大的情况下，是怎么做到根据messageId、message-key、时间范围这些
Kafka
weixin_41120085的博客
10-28 119
文章目录一、kafka 应用场景二、Kafka主要特点三、Kafka的架构四、几个基本概念五、环境搭建 一、kafka 应用场景 1.日志收集：一个公司可以用Kafka可以收集各种服务的log，通过kafka以统一接口服务的方式开放给各种consumer，例如hadoop、Hbase、Solr等。 2.消息系统：解耦和生产者和消费者、缓存消息等。 3.用户活动跟踪：Kafka经常被用来记录web用户或者app用户的各种活动，如浏览网页、搜索、点击等活动，这些活动信息被各个服务器发布到kafka的topic
RabbitMQ高级之如何保证消息可靠性？
Java笔记虾
09-08 670
本文来源：http://r6f.cn/aTWx楔子本篇是消息队列RabbitMQ的第四弹。RabbitMQ我已经写了三篇了，基础的收发消息和基础的概念我都已经写了，学任何东西都是这样，先...
中间件
taihexuelang的专栏
08-15 207
nginx集群 mq集群 redis集群 mysql集群 监控工具
RocketMq--key和tag的作用及容易踩坑的点
wodiaonihai的博客
01-12 1万+
Producer 实例 Producer 的一个对象实例，不同的 Producer 实例可以运行在不同进程内或者不同机器上。Producer 实例线程安全，可在同一进程内多线程之间共 享。 Message Key Key 一般用于消息在业务层面的唯一标识。对发送的消息设置好 Key，以后可以根据这个 Key 来查找消息。比如消息异常，消息丢失，进行查找会很 方便。RocketMQ 会创建专门的索引文件，用来存储 Key 与消息的映射，由于是 Hash 索引，应尽量使 Key 唯一，避免潜在的哈希冲突。 Ta
源码分析RocketMQ之消费队列、Index索引文件存储结构与存储机制-上篇
最新发布
2401_84002730的博客
04-27 688
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
RocketMQ源码分析之消费队列、Index索引文件存储结构与存储机制-上篇
qq_33291299的博客
02-28 269
代码@1：首先将一条 ConsueQueue 条目总共20个字节，写入到 ByteBuffer 中。代码@2：计算期望插入 ConsumeQueue 的 consumequeue 文件位置。代码@3：如果文件是新建的，需要先填充空格。代码@4：写入到 ConsumeQueue 文件中，整个过程都是基于 MappedFile 来操作的。我们现在已经知道 ConsumeQueue 每一个条目都是 20个字节（8个字节commitlog偏移量+4字节消息长度+8字节tag的hashcode。
RocketMQ源码分析(十四)之IndexFile
jannal专栏
08-17 223
RocketMQ源码-IndexFile
通过这三个文件彻底搞懂rocketmq的存储原理
05-01 1049
前言 RocketMQ是阿里开发的一个高性能的消息队列，支持各种消息类型，而且支持事务消息，可以说是现在的很多系统中的香饽饽了，所以呢，怎么使用大家肯定是要学习的 我们作为一个有梦想的程序员，在学习一门技术的时候，肯定是不能光知其然，这是远远不够的，我们必须要知其所以然，这样才能在面试的时候侃侃而谈，啊呸，不对，这样我们才能在工作中遇到问题的时候，理性的去思考如何解决问题 我们知道RocketMQ的架构是producer、NameServer、broker、Consumer，producer是生产消息的，.
RocketMQ 关键特性
weixin_33811961的博客
12-09 243
Apache RocketMQ之所以能在众多的消息中间件中脱颖而出，能吸引数千企业用户与RocketMQ的关键特性是分不开的，本文详细介绍RocketMQ中的关键特性。 一、过万的单机队列数 诸如Kafka之类的消息中间件，在队列数上升时性能会产生巨大的损失，RocketMQ之所以能单机支持上万的持久化队列与其独特的存储结构分不开。 如上图所示，所有的...
RocketMQ基础概念及使用总结
从前不爱吃面的大叔
11-20 1万+
一．了解RocketMQ？ rocketMQ是阿里开源的一款十分优秀的消息队列，rocketMQ具有很多其他消息队列不具有的特性，像事务消息，推拉结合的Api等等。更重要的是rocketMQ是用java开发的，像RabbitMQ这种用erlang进行开发，对于我们搞java的来说学习成本不言而喻。并且经历了双11的数据洪峰的考验，rocketMQ已经加入了apache。成为apache的顶级项目
rocketmq 的索引策略
chixingmang8023的博客
08-28 451
IndexFile 存储具体消息索引的文件，文件的内容结构如图： 索引文件由索引文件头IndexHeader, 槽位Slot和消息的索引内容三部分构成 IndexHeader:索引文件头信息40个字节的数据组成 beginTimestamp 8位long类型，索引文件构建第一个索引的...
RocketMQ（14）——发送带Key的消息
Elim的博客
09-06 1784
如果业务里面的某一条消息有问题，通过Topic查询出来的是一堆的消息，虽然说可以通过时间范围查找，但是在某个时间范围内的消息有可能也成千上万，很难找到业务对应的那条。而通过Key进行查找的时候，Key就是我们的业务ID，很容易获得，Key往往是唯一的，那么查询出来的消息也将是唯一的那条。比如下面代码一共发送了10条消息，第一条消息的Key是0、1、2,第二条消息的Key是1、2、3,最后一条消息的Key是9、10、11。发送消息的时候可以指定一个Key，这个Key通常就是消息对应的某种业务的主键。
源码分析RocketMQ系列索引
热门推荐
中间件兴趣圈
12-24 3万+
1、RocketMQ源码分析之NameServer 2、RocketMQ源码分析之Broker概述与同步消息发送原理与高可用设计及思考 3、源码分析RocketMQ之CommitLog消息存储机制 4、源码分析RocketMQ之消息消费 5、源码分析RocketMQ消息消费机制----消费者拉取消息机制 6、 源码分析RocketMQ消息消费机制----消费端消息负载均衡机制与重新分布 ...
系列十二（实战）、发送 & 接收带Key的消息（Java操作RocketMQ）
仰望星空，脚踏实地！安全感是自己给的，努力才是一辈子的安全感。
12-25 824
在RocketMQ的消息中，如果没有未消息设定Key那么会有一个默认的Key，如下：但是对于一些特殊的场景，例如交易系统，按照orderSn查找是一个和常见的操作，那么这种情况下就涉及到了如何在发送消息的时候，指定消息的Key了。请看下面的案例。
RocketMQ架构原理解析（三）：消息索引（ConsumeQueue & IndexFile）
sjzsylkn的专栏
12-13 1564
一、概述 “索引”一种数据结构，帮助我们快速定位、查询数据 前文我们梳理了消息在Commit Log文件的存储过程，讨论了消息的落盘策略，然而仅仅通过Commit Log存储消息是远远不够的，例如当我们需要消费某个topic的消息时，通过对Commit Log整体遍历寻找消息的方式无疑非常的低效。所以本章将引出2个很重要的概念：消费队列、IndexFile 二、消费队列 2.1 概念 什么是消费队列呢？其实在上一章的消息协议格式中，就有消息队列的体现，简单回顾一下协议的前6个字段： msg total
RocketMQ学习
qq_43338864的博客
02-07 1244
PUSH:队列有消息都会进行投递实时性很强导致客户端压力过大PULL:消费者主动去MQ拉消息，压力可控但是实时性不强 拉取频率需要自己控制，拉取频繁造成服务端客户端压力，拉取间隔时间过长容易造成消费不及时。匀速场景下PUSH模式 大部分场景下poll模式消费者通过长轮询进行消费。
akka-2 利用模式匹配，实现worker节点向master报告本机配置信息
Big_data_implicit_
11-01 194
1、创建本机配置信息类 * WorkInfo * Worker的本机信息类 * id:主机名称 momery:内存大小 cores:CPU核数 直接使用默认构造创建消息类 /** * Worker的本机信息类 * id:主机名称 momery:内存大小 cores:CPU核数 */ class WorkerInfo(val id: String, var memory: Int, var cores: Int) { override def toString: String .
RocketMQ原理详解：构建高效消息传递架构
RocketMQ原理介绍 RocketMQ是阿里巴巴开源的消息中间件，由淘宝消息中间件项目组开发，最初于2013年发布，v3.0.0版本是在同年五月和八月进行了补充和完善。该文档旨在深入解析RocketMQ的核心原理、设计与功能，帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值