2024年Go最全redis源码阅读—zskiplist 跳跃表_0(3)，Golang入门视频教程

2401_84925335

于 2024-05-11 04:16:23 发布

阅读量770

点赞数 20

分类专栏：程序员文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84925335/article/details/138692539

版权

程序员专栏收录该内容

57 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

结构定义和详细介绍

源码：server.h zskiplistNode和zskiplist的数据结构定义
t_zset.c 以zsl开头的函数是SkipList相关的操作函数

zskiplist 结构

在这里插入图片描述

typedef struct zskiplist {
	// 表头的头指针header和尾指针tail 
    struct zskiplistNode \*header, \*tail;
    // 节点的数量
    unsigned long length;
    // 所有节点的最大层数
    int level;
} zskiplist;

header和tail指针分别指向跳跃表的表头节点和表尾节点，通过这两个指针，定位表头节点和表尾节点的复杂度为O(1)。表尾结点是表中最后一个节点，而表头节点实际上是一个伪节点，该节点的成员对象为NULL ，分值为0，它的固定层数为32(现为64 层的最大值)

length属性记录节点的数值，程序可以在O(1)的时间复杂度返回跳跃表的长度

level属性记录跳跃表的层数，也就是表中层高最大的那个节点的层数，注意：表头节点的层高不计算在内

完整的跳跃表结构
在这里插入图片描述

zskiplistnode结构

在这里插入图片描述

/\* ZSETs use a specialized version of Skiplists \*/
typedef struct zskiplistNode {
	// 数据域 具体数据，对应的张三 
    sds ele;
    // 分数 
    double score;
    // 后退指针
    struct zskiplistNode \*backward;
    // 层级数组
    struct zskiplistLevel {
        // 前进指针
        struct zskiplistNode \*forward;
        // 跨度 
        unsigned long span;
    } level[];//level本身是一个弹性数组，最大值为32，由 ZSKIPLIST\_MAXLEVEL 定义
} zskiplistNode;

sds ele具体的数据在之前的版本中 robj *obj 标识节点的成员对象的指针

score 对象的分数是一个浮点数跳跃表中所有的节点都是根据score从小到大来排序的同一个跳跃表中，各个结点保存的成员对象必须是唯一的，但是多个结点保存的分值却可以是相同的：分值相同的结点将按照成员对象的字典顺序从小到大进行排序。

*backward 节点的后退指针用于从表尾向表头方向访问节点：跟可以一次跳过多个节点的前进指针不同，因为每个节点只有一个后退指针，所以每次只能后退至前一个节点

level 跳跃表节点的数组可以包含多个元素，每个元素都包含一个指向其他节点的指针，程序可以通过这些层来加快访问其他节点的速度，一般来说，层的数量越多，访问其他节点的速度就越快。
每次创建一个新跳跃表节点的时候，程序根据幂次定律 ( power law，越大的数出现的概率越小)随机生成一个介于 1 和 32 之间的值作为 level 数组的大小，这个大小就是层的“高度”。

*forward 每个层都有一个指向表尾方向的前进指针(level[i].forward属性)，用于从表头向表尾方向访问节点

层的跨度（level[i].span 属性）用于记录两个节点之间的距离：
两个节点之间的跨度越大，它们相距得就越远。
指向 NULL 的所有前进指针的跨度都为 0 ，因为它们没有连向任何节点。

操作API

创建

创建空的跳跃表，其实就是创建表头和管理所有的节点的level数组。首先，定义一些变量，尝试分配内存空间。其次是初始化表头的level和length，分别赋值1和0。接着创建管理所有节点的Level的数组，是调用zslCreateNode函数，输入参数为数组大小宏常量ZSKIPLIST_MAXLEVEL（64），分数为0，对象值为NULL。(此为跳跃表得以实现重点)。再接着就是为此数组每个元素的前指针forword和跨度span初始化。最后初始化尾指针并返回值。
在这里插入图片描述

/\* Create a skiplist node with the specified number of levels.
 \* The SDS string 'ele' is referenced by the node after the call. \*/
zskiplistNode \*zslCreateNode(int level, double score, sds ele) {
    zskiplistNode \*zn =
        zmalloc(sizeof(\*zn)+level\*sizeof(struct zskiplistLevel));
    zn->score = score;
    zn->ele = ele;
    return zn;
}

/\* Create a new skiplist. \*/
zskiplist \*zslCreate(void) {
    int j;
    zskiplist \*zsl;

    // 尝试分配内存空间
    zsl = zmalloc(sizeof(\*zsl));
    // 初始化level和length
    zsl->level = 1;
    zsl->length = 0;
    /\*
 调用下面的方法zslCreateNode 
 参数
 数组长度ZSKIPLIST\_MAXLEVEL 64
 score 分数为0
 具体的元素
 这一步就是创建管理所有节点的数组
 并且设置表头的头指针为该数组对象的地址
 \*/
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
    // 为这个64位的数组赋值前进指针forword和跨度span
    for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
        zsl->header->level[j].forward = NULL;
        zsl->header->level[j].span = 0;
    }
    // 设置尾指针
    zsl->header->backward = NULL;
    zsl->tail = NULL;
    return zsl;
}

随机算法

一个具有k个后继指针的结点称为k层结点。假设k层结点的数量是k+1层结点的P倍，那么其实这个跳跃表可以看成是一棵平衡的P叉树。跳跃表结点的层数，采用随机化算法得到，实现如下

/\* Returns a random level for the new skiplist node we are going to create.
 \* The return value of this function is between 1 and ZSKIPLIST\_MAXLEVEL
 \* (both inclusive), with a powerlaw-alike distribution where higher
 \* levels are less likely to be returned. \*/
int zslRandomLevel(void) {
    int level = 1;
    while ((random()&0xFFFF) < (ZSKIPLIST_P \* 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

ZSKIPLIST_P为0.25 level 初始化1 然后，如果持续满足条件：(random()&0xFFFF)< (ZSKIPLIST_P * 0xFFFF)的话，则level+=1。最终调整level的值，使其小于ZSKIPLIST_MAXLEVEL。

理解该算法的核心，就是要理解满足条件：**(random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF)**的概率是多少？

random()&0xFFFF形成的数，均匀分布在区间[0,0xFFFF]上，那么这个数小于(ZSKIPLIST_P * 0xFFFF)的概率是多少呢？自然就是ZSKIPLIST_P，也就是0.25了。

因此，最终返回level为1的概率是1-0.25=0.75，返回level为2的概率为0.250.75，返回level为3的概率为0.250.250.75…因此，如果返回level为k的概率为x，则返回level为k+1的概率为0.25x，换句话说，如果k层的结点数是x，那么k+1层就是0.25*x了。这就是所谓的幂次定律（powerlaw），越大的数出现的概率越小。

0xFFFF int(65535)

插入

虽然整个代码较长，但是从整体逻辑上可以分为三部分：
* 1：根据目前传入的score找到插入位置x，这个过程会保存各层x的前一个位置节点
* 就像我们对有序单链表插入节点的时候先要找到比目前数字小的节点保存下来。
* 2：根据随机函数获取level，生成新的节点
* 3：修改各个指针的指向，将创建的新节点插入。

/\* Insert a new node in the skiplist. Assumes the element does not already
 \* exist (up to the caller to enforce that). The skiplist takes ownership
 \* of the passed SDS string 'ele'. \*/
/\*
插入节点
参数：
 zsl 表头
 score 插入元素的分数
 ele 插入元素的具体数据
\*/
zskiplistNode \*zslInsert(zskiplist \*zsl, double score, sds ele) {
    // 使用update数组记录每层待插入元素的前一个元素 
    zskiplistNode \*update[ZSKIPLIST_MAXLEVEL], \*x;
    // 记录前置节点与第一个节点之间的跨度 即元素在列表中的排名-1
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    serverAssert(!isnan(score));
    x = zsl->header;
    // 从最大的level开始遍历 从顶到底 找到每一层待插入的位置
    for (i = zsl->level-1; i >= 0; i--) {
        /\* store rank that is crossed to reach the insert position \*/
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        // 直接找到第一个分数比该元素大的位置
        // 或者分数与该以元素相同但是对象的ASSIC码比该元素大的位置
        while (x->level[i].forward &&
                (x->level[i].forward->score < score ||
                    (x->level[i].forward->score == score &&
                    sdscmp(x->level[i].forward->ele,ele) < 0)))
        {
            //将已走过元素的跨越元素进行计数，得到元素在列表中排名，或者是已搜寻的路径长度
            rank[i] += x->level[i].span;
            x = x->level[i].forward;
        }
        // 记录待插入位置
        update[i] = x;
    }
    /\* we assume the element is not already inside, since we allow duplicated
 \* scores, reinserting the same element should never happen since the
 \* caller of zslInsert() should test in the hash table if the element is
 \* already inside or not. \*/
    // 随机产生一个层数，在1到32之间，层数越高，生成的概率越低
    level = zslRandomLevel();
    // 如果产生的层数大于现有的最高层数 则超出层数需要初始化
    if (level > zsl->level) {
    	// 循环遍历
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            //该元素作为这些层的第一个节点，前节点就是header
            update[i] = zsl->header;
            //初始化后这些层每层有两个元素，走一步就是跨越所有元素
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;
    }
    //创建节点
    x = zslCreateNode(level,score,ele);
    for (i = 0; i < level; i++) {
    	//将新节点插入到各层链表中
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;
		// rank[0]是第0层的前置节点P1（也就是底层插入节点前面那个节点）与第一个节点的跨度
        // rank[i]是第i层的前置节点P2（这一层里在插入节点前面那个节点）与第一个节点的跨度
        // 插入节点X与后置节点Y的跨度f(X,Y)可由以下公式计算
        // 关键在于f(P1,0)-f(P2,0)+1等于新节点与P2的跨度，这是因为跨度呈扇形形向下延伸到最底层
        // 记录节点各层跨越元素情况span, 由层与层之间的跨越元素总和rank相减而得
        /\* update span covered by update[i] as x is inserted here \*/
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
        // 插入位置前一个节点的span在原基础上加1即可(新节点在rank[0]的后一个位置)
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }

    /\* increment span for untouched levels \*/
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }
	// 第0层是双向链表, 便于redis常支持逆序类查找
    x->backward = (update[0] == zsl->header) ? NULL : update[0];
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;
    zsl->length++;
    return x;
}

插入的代码比较长我们分段进行分析解读
第一部分：寻找插入结点在每层上的前驱结点的代码

x = zsl->header;
// 从最大的level开始遍历 从顶到底 找到每一层待插入的位置
for (i = zsl->level-1; i >= 0; i--) {
    /\* store rank that is crossed to reach the insert position \*/
    rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
    // 直接找到第一个分数比该元素大的位置
    // 或者分数与该以元素相同但是对象的ASSIC码比该元素大的位置
    while (x->level[i].forward &&
            (x->level[i].forward->score < score ||
                (x->level[i].forward->score == score &&
                sdscmp(x->level[i].forward->ele,ele) < 0)))
    {
        //将已走过元素的跨越元素进行计数，得到元素在列表中排名，或者是已搜寻的路径长度
        rank[i] += x->level[i].span;
        x = x->level[i].forward;
    }
    // 记录待插入位置
    update[i] = x;
}

从表头结点的最高层开始查找，首先在该层中寻找插入结点的前驱结点。只要插入结点比当前结点x在该层的后继结点x->level[i].forward要大，则首先记录x后继结点的排名：rank[i] += x->level[i].span; 接着开始比较x的后继结点：x =x->level[i].forward。

注意，因为Redis中的跳跃表中，允许分数重复而不允许成员对象重复。所以，这里的判断条件中，一旦分数相同，则要比较成员对象的字典顺序。

一旦当前结点x的后继结点为空，或者后继结点比插入结点要大，说明找到了插入结点在该层的前驱结点，记录到update数组中：update[i] = x，此时，rank[i]就是结点x的排名。

然后，开始遍历下一层，从x结点开始比较。

第二部分：将节点插入到跳跃表中

//创建节点
// 随机产生一个层数，在1到32之间，层数越高，生成的概率越低
level = zslRandomLevel();
// 如果产生的层数大于现有的最高层数 则超出层数需要初始化
if (level > zsl->level) {
	// 循环遍历
    for (i = zsl->level; i < level; i++) {
        rank[i] = 0;
        //该元素作为这些层的第一个节点，前节点就是header
        update[i] = zsl->header;
        //初始化后这些层每层有两个元素，走一步就是跨越所有元素
        update[i]->level[i].span = zsl->length;
    }
    zsl->level = level;
}

首先利用zslRandomLevel，生成一个随机的层数level。如果该level大于当前跳跃表的最大level的话，则需要初始化插入结点在超出层上，也就是在层数[zsl->level, level)上的前驱结点及其排名。这里直接初始化前驱结点为头结点，排名为0，并且初始化前驱结点在相应层上的层跨度为zsl->length，也就是头结点和尾节点之间的距离。

然后更新zsl->level的值。需要注意的是，因Redis中，使用哈希表和跳跃表两种结构表示有序集合，因此，在跳跃表的插入操作中，无需判断插入结点是否与表中结点重复，这是因为在调用zslInsert之前，调用者应该已经使用哈希表进行过检测了。

第三部分：

 //创建节点
 x = zslCreateNode(level,score,ele);
 for (i = 0; i < level; i++) {
 	//将新节点插入到各层链表中
     x->level[i].forward = update[i]->level[i].forward;
     update[i]->level[i].forward = x;
// rank[0]是第0层的前置节点P1（也就是底层插入节点前面那个节点）与第一个节点的跨度
     // rank[i]是第i层的前置节点P2（这一层里在插入节点前面那个节点）与第一个节点的跨度
     // 插入节点X与后置节点Y的跨度f(X,Y)可由以下公式计算
     // 关键在于f(P1,0)-f(P2,0)+1等于新节点与P2的跨度，这是因为跨度呈扇形形向下延伸到最底层
     // 记录节点各层跨越元素情况span, 由层与层之间的跨越元素总和rank相减而得
     /\* update span covered by update[i] as x is inserted here \*/
     x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
     // 插入位置前一个节点的span在原基础上加1即可(新节点在rank[0]的后一个位置)
     update[i]->level[i].span = (rank[0] - rank[i]) + 1;
 }

 /\* increment span for untouched levels \*/
 for (i = level; i < zsl->level; i++) {
     update[i]->level[i].span++;
 }

首先调用zslCreateNode创建一个跳跃表节点。然后在层数[0, level)中，根据update[i]记录的每层上的前驱结点，将新结点插入到每层中。

接着更新每层上，新结点及其前驱结点的层跨度。节点的层跨度，等于该节点在第i层上的后继节点的排名，减去该节点的排名。

新结点在第i层的后继节点，也就是之前update[i]的后继节点，它的排名是update[i]->level[i].span+ rank[i]，插入新结点之后，它的排名加1，也就是update[i]->level[i].span + rank[i] + 1。新结点的排名，就是rank[0]+ 1，因此，新结点在第i层的层跨度就是(update[i]->level[i].span + rank[i] + 1) – (rank[0] + 1)，也就是update[i]->level[i].span- (rank[0] - rank[i])。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

– (rank[0] + 1)，也就是update[i]->level[i].span- (rank[0] - rank[i])。

[外链图片转存中…(img-VBEssv5M-1715372160444)]
[外链图片转存中…(img-lu0ENYYg-1715372160444)]
[外链图片转存中…(img-QgfCVYzA-1715372160445)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

2401_84925335

关注

20
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
2024年Go最全redis源码阅读—zskiplist 跳跃表_0(3)，Golang入门视频教程

源码：server.h zskiplistNode和zskiplist的数据结构定义t_zset.c 以zsl开头的函数是SkipList相关的操作函数。
复制链接

扫一扫