深入解读redis的zset和跳表【源码分析】

已于 2023-10-08 12:59:10 修改
阅读量474 收藏 1
点赞数
文章标签： redis 数据库 缓存
于 2023-10-07 22:23:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaopu0120/article/details/133641027
版权

1.基本指令

部分指令，涉及到第4章的api，没有具体看实现，但是逻辑应该差不多。

  • zadd <key><score1><value1><score2><value2>...
    • 将一个或多个member元素及其score值加入到有序集key当中。
    • 根据zslInsert
  • zrange <key><start><stop>[WITHSCORES]
    • 返回有序集key中，下标在 之间的元素
    • 根据zslGetElementByRank以及backward指针
  • zrangebyscore key min max [withscores] [limit offset count]
    • 返回有序集 key 中，所有score值介于min和max 之间(包括等于min或max )的成员
    • 根据zslFirstInRange和zslLastInRange以及backward指针
  • zrank <key><value>
    • 返回该值在集合中的排名，从0开始。
    • 根据zslGetRank

2.数据结构

ZSET是由有序集合跳表实现的，按照分值的大小排序，分值相同时，按照成员对象的大小进行排序。同一个跳表可以有同分值的节点，但是对象必须是唯一的。
在这里插入图片描述
定义结构的代码src/server.h

// 1.ZSET节点
/* ZSETs use a specialized version of Skiplists */
typedef struct zskiplistNode {
	// member元素的value
    sds ele;
    // member元素的score
    double score;
    // 后向指针
    struct zskiplistNode *backward;
    // 层
    struct zskiplistLevel {
        // 前进指针
        struct zskiplistNode *forward;
        // 跨度
        unsigned long span;
    } level[];
} zskiplistNode;

// 2.ZSET链表
typedef struct zskiplist {
	// 头节点和尾节点
    struct zskiplistNode *header, *tail;
    // 节点的数量(不包括头节点)
    unsigned long length;
    // 表中层数最大节点的层数
    int level;
} zskiplist;

结合上方的图容易理解，其中有一些值得注意的点

  1. header表头节点只有level，没有存放元素的value和score。在zskiplist的length也不包括头节点。
  2. 每一层都有两个属性：前向forward指针和跨度。前向指针指向包含同一层的下一个结点，跨度记录了两个节点间的距离。指向NULL的跨度都为0。跨度是用来计算排位rank的，在查找某个节点的过程中，将沿途访问过的所有层跨度累计起来，就能得到目标节点的排位。
  3. 后向backward指针指向当前节点的前一个节点。目的是逆序遍历。和range有关的指令，可以获得range范围的首尾节点后，从尾节点遍历到首节点。（只有backward指针是遍历相邻节点，forward指针每一层都有，指向的间隔为span的节点，不是下一个节点）
        if (reverse) {
            ln = zslLastInRange(zsl,range);
        } else {
            ln = zslFirstInRange(zsl,range);
        }

        /* If there is an offset, just traverse the number of elements without
         * checking the score because that is done in the next loop. */
        while (ln && offset--) {
            if (reverse) {
                ln = ln->backward;
            } else {
                ln = ln->level[0].forward;
            }
        }
  1. 每次创建一个跳表节点时，根据幂次定律随机生成一个介于1到32之间的值作为level数组的大小。(见第3章节复杂度分析)
  2. 节点的score是一个double类型的浮点数，成员对象value是一个SDS(字符串对象)。如果想用zset实现两个维度排序，可以用拼接的思想。

3.跳表通用复杂度分析

跳表的复杂度和level的层数有关，如果只有一层，那复杂度必然都是最坏情况O(N)。一个节点有多少层来自于下面这个函数，在新建节点时，根据幂次定律生成一个1到32间的随机数。
可以理解为有概率P多加一层。

int zslRandomLevel(void) {
    static const int threshold = ZSKIPLIST_P*RAND_MAX;
    int level = 1;
    while (random() < threshold)
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

我们知道完全二叉树的复杂度推导是
2 h − 1 = N 2^h-1=N 2h−1=N
h = l o g 2 ( N + 1 ) h=log_2(N+1) h=log2​(N+1)所以平均查找的时间复杂度是O(log(N))
跳表相当于一个多叉树，叉为 1 P \frac{1}{P} P1​。（每一个节点有P的概率加一层，那相邻两层的节点数比为P。由于跳表最多32层，相邻两层实际节点数也不严格为P，所以这是一个近似的概念。）
复杂度推导为
( 1 P ) h − 1 − 1 = N (\frac{1}{P})^{h-1}-1=N (P1​)h−1−1=N
h = l o g 1 p ( N + 1 ) h=log_{\frac{1}{p}}(N+1) h=logp1​​(N+1)
如果p=0.25， h = 0.5 ∗ l o g 2 ( N + 1 ) h=0.5*log_2(N+1) h=0.5∗log2​(N+1)
如果p=0.5， h = l o g 2 ( N + 1 ) h=log_2(N+1) h=log2​(N+1)
所以p在一定范围都是O(log(N))级别的复杂度。P在极端情况下(比如接近0或1)会变成O(N)。

推导比较粗糙，可能有问题

4.API复杂度分析

4.1. 查找元素

zslFirstInRange找到分值范围的第一个元素；zslLastInRange找到分值范围的最后一个元素
平均O(logN)，最坏O(N)

zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;
    /* 判断跳表分数的范围是否在该范围内 */
    if (!zslIsInRange(zsl,range)) return NULL;
    x = zsl->header;
    /** 从最高的层数开始遍历，直到最底层 **/
    for (i = zsl->level-1; i >= 0; i--) {
        /* 在同一层通过前向指针遍历，直到下一个节点为空或者下一节点分数大于等于范围最小值，进入下一层 */
        while (x->level[i].forward &&
            !zslValueGteMin(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }

    /* This is an inner range, so the next node cannot be NULL. */
    /* 下一节点就是目标值 */   
    x = x->level[0].forward;
    serverAssert(x != NULL);

    /* Check if score <= max. */
    if (!zslValueLteMax(x->score,range)) return NULL;
    return x;
}
int zslValueGteMin(double value, zrangespec *spec) {
    return spec->minex ? (value > spec->min) : (value >= spec->min);
}

4.2. 判断分值是否在范围

zslIsInRange判断是否至少一个节点的分值在范围内
O(1)，根据头尾节点实现。zslFirstInRange和zslLastInRange都会先调用这个函数进行判断。

/* 存在返回1，不存在返回0 */
int zslIsInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    /* 对值的范围进行判定 */
    if (range->min > range->max ||
            (range->min == range->max && (range->minex || range->maxex)))
        return 0;
    // 1.获取尾节点，尾节点的分数不大于等于(就是小于)范围的最小值返回0
    x = zsl->tail;
    if (x == NULL || !zslValueGteMin(x->score,range))
        return 0;
    // 2.获取头节点，头节点的分数大于范围的最大值返回0
    x = zsl->header->level[0].forward;
    if (x == NULL || !zslValueLteMax(x->score,range))
        return 0;
    return 1;
}

4.3. 添加元素

zslInsert添加元素
平均O(logN)，最坏O(N)

zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
	/* 为了插入节点到正确位置，存储遍历过程中每一层最尽头的节点，其实就是新节点的上一个节点(该节点的forward指向新节点)*/
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    /* 为了更新span，存储遍历过程中每一层的rank */
    unsigned long rank[ZSKIPLIST_MAXLEVEL];
    int i, level;
	
    serverAssert(!isnan(score));
    /**和查找类似的思路**/
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        /* 存储每一层的rank值 */
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        /* 在同一层通过前向指针遍历，直到
        	1.下一个节点为空
        	2.下一节点分数大于等于范围最小值
        	3.节点分数相同元素值更大
        进入下一层 */
        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)))
        {
        	/* 累加span获得rank */
            rank[i] += x->level[i].span;
            x = x->level[i].forward;
        }
        /* 记录每一层最末节点 */
        update[i] = x;
    }
    
	/* 获取一个随机的level层数 */
    level = zslRandomLevel();
    /* 如果新层数大于原跳表最大层数，更新zsl-level，并将超出的层记录下来 */
    if (level > zsl->level) {
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0; 
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length; 
        }
        zsl->level = level; 
    }

    x = zslCreateNode(level,score,ele);
    /* 更新新节点和每层新节点前一个节点的forward和span */
    for (i = 0; i < level; i++) {
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;

        /* update span covered by update[i] as x is inserted here */
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }

    /* increment span for untouched levels */
    /* 高于该节点的每一个span因为插入了一个节点所以要增加1 */
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }
	
	/* 更新backward指针 */
    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;
}

4.4.获取成员排位

zslGetRank返回包含给定成员和score的节点的排位
平均O(logN)，最坏O(N)

unsigned long zslGetRank(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *x;
    unsigned long rank = 0;
    int i;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        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 */
            rank += x->level[i].span;
            x = x->level[i].forward;
        }

        /* x might be equal to zsl->header, so test if obj is non-NULL */
        if (x->ele && x->score == score && sdscmp(x->ele,ele) == 0) {
            return rank;
        }
    }
    return 0;
}

4.5. 获取某排位节点

zslGetElementByRank返回跳跃表在给定排位上的节点

zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
    zskiplistNode *x;
    /* 记录了遍历过程中的rank累加值 */
    unsigned long traversed = 0; 
    int i;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (traversed + x->level[i].span) <= rank)
        {
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        if (traversed == rank) {
            return x;
        }
    }
    return NULL;
}

参考

  1. 《redis的设计与实现》
  2. redis源码-7.2.1
是朴啊朴
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis键值数据库源码分析
02-05
test:（测试） memtest.c 内存检测 redis_benchmark.c 用于redis性能测试的实现。 redis_check_aof.c 用于更新日志检查的实现。 redis_check_dump.c 用于本地数据库检查的实现。 testhelp.c 一个C风格的...t_zset.c zs
使用Redis的zset集合实现小程序的滚动分页
lovoo的博客
06-03 1379
其中，ZRangeArgs构造函数中的参数表示从集合的起始位置开始返回文档ID，lastDocId表示只返回大于lastDocId且score值小于当前时间戳的文档ID，86400000L表示一天的毫秒数，表示向前滚动一页。
Redis源码-ZSet：Redis ZSet存储原理、Redis ZSet命令、 Redis ZSet两种存储底层编码ziplist/dict+skiplist、Redis ZSet应用场景
郝开的博客
09-09 1648
扩容的量级是原dictht的2的n次方，扩容之后，会把原表的数据重新分配到新表(rehash，重新计算hash)，然后用ht[0]标记为当前使用的是哪个表，清空原先的dictht来释放空间。Redis中的Hash结构，在Redis中，所有的KV存储方式都是基于dict（外层Hash表，HashTable）这个结构去存存储的，那么如果value的编码类型也是。有序链表，根据分值去执行插入数据，会从前到后遍历一遍，才能找到合适的位置，时间复杂度O(n)，与链表的长度有关，怎么优化一下查找速度？
Redis高级之底层源码5——ZSet数据结构底层源码分析
geminigoth的博客
10-15 95
Redis使用跳跃表作为有序集合键的底层实现之一，如果一个有序集合包含的元素数量比较多，或者有序集合中的元素是比较长的字符串，Redis就会使用跳跃表来作为有序集合键的底层实现。
redis源码阅读-zset
yxkong的专栏
07-31 562
前段时间给小伙伴分享redis，顺带又把redis撸了一遍了，对其源码，又有了比较深入的了解。（ps分享的文章再丰富下再放出来）。
Redis 为什么用跳表，而不用平衡树？
m0_71777195的博客
08-11 1173
其中提到，ZSet 对象的底层数据结构实现之一是跳表。然后，有读者就问：为什么不使用平衡树（如红黑树、AVL 树）？我们先来了解下跳表，再来回答这个问题。
redis源码日志（源码分析）
01-27
redis源码日志是对redis源码的分析解读，适用于学习。 介绍了redis是如何实现高并发、海量数据存贮的。 资源是PDF格式，有完整书签，也很清晰。
Redis源码解读与项目精品设计实战
07-28
Redis源码解读与项目精品设计实战Redis源码解读与项目精品设计实战Redis源码解读与项目精品设计实战
基于Scrapy和Redis的分布式爬虫设计源码
最新发布
04-17
本项目是基于Python开发的基于Scrapy和Redis的分布式爬虫设计源码，共包含21个文件。其中Python编译后的pyc文件7个，Python源代码文件7个，XML配置文件3个，Git忽略配置文件1个，Markdown文档1个，项目配置文件1个，...
redis源码分析——zset
JnX的专栏
06-20 700
这里写自定义目录标题zset是什么skiplist数据结构level的计算插入结点删除结点功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图...
上手Redis系列(五)：超全有序集合Zset类型详解（代码图文示例）
一颗剽悍的种子的博客
07-28 582
学习Redis五种类型之一的Zset之前，我还是觉得我务必跟你说一声，也是在我文章之中说的很多的一句话，我想也会适用于学习Redis，那就是在接触文章里的Reids命令时，不用试图去记这些命令 ，用到时去看API帮助文档即可;会用了或者实践过了再去了解也不会迟。 上手Redis系列 上手Redis必知必会：最基础知识点和最基本常用操作（代码示例） 上手Redis系列(一)：超全String字符串类型详解（代码图文示例） 上手Redis系列(二)：超全List列表类型详解（代码图文示例） 上手Redis.
【Redis源码剖析】 - Redis数据类型之有序集合zset
上善若水，人淡如菊
04-24 1万+
原创作品，转载请标明：http://blog.csdn.net/Xiejingfa/article/details/51231967 Redis源码剖析系列文章汇总：传送门 这周事情比较多，原本计划每周写两篇文章的任务看来是完不成了。今天为大家带来有序集合zset的源码分析。 Redis中的zset主要支持以下命令： zadd、zincrby zrem、zremrangebyrank、...
Redis从精通到入门——数据类型Zset实现源码详解
“实用”是软件压倒一切的要素
02-06 1591
Zset简介，Zset常用操作，应用场景，Zset实现，源码阅读，Zset—ziplist实现，图解Zset—ziplist，Zset—字典(dict) + 跳表(zskiplist)实现，源码阅读，图解zskiplist
Redis 6.0 源码阅读笔记(7)-ZSet 数据类型源码分析
谈谈1974
09-29 677
文章目录1. 存储结构2. 源码解析 1. 存储结构 在 有序集合对象 ZSet 的介绍中已经提到 ZSet 集合的底层存储结构主要有两种，其结构实例如下： OBJ_ENCODING_ZIPLIST 当 ziplist 作为 zset 的底层存储结构时，每个集合元素使用两个紧挨在一起的压缩列表节点来保存，第一个节点保存元素值，第二个元素保存元素的分值，而且分值小的靠近表头，大的靠近表尾 OBJ_ENCODING_SKIPLIST 底层实现是跳跃表结合字典。每个跳跃表节点都保存一个集合元素，并按分值
Redis源码剖析和注释（十三）--- 有序集合类型键实现(t_zset)
men_wen的博客
05-01 3163
有序集合类型键实现1. 有序集合命令Redis有序集合命令如下表所示：Redis 有序集合命令详解 序号 命令及描述 1 ZADD key score1 member1 [score2 member2]： 向有序集合添加一个或多个成员，或者更新已存在成员的分数 2 ZCARD key： 获取有序集合的成员数 3 ZCOUNT key min max：计算在有序集合中指定
redis源码分析与思考（八）——对象
溯夜，逆流而上
10-10 392
谈及对象，我们不免会立即联想到Java、C++等面向对象的语言，而在C中是没有对象这一说法的，为了方便管理与代码整体的优化，redis基于前面几篇博客的数据结构自建了一套对象系统。这个系统包含着字符串对象、列表对象、哈希对象、集合对象以及有序集合对象。构建这一对象系统最为直接的好处就是该对象可以根据不同的场景去使用不同的数据结构来实现，提高了效率。
redis源码阅读之四(zset)
ijbuhv的专栏
04-21 185
zset是redis的有序集合对象，它是由skipList和dict这两种数据结构来实现的(在数据量较小的时候是用的zipList来实现的)。 其中skipList主要是zrank,zrange 这些操作能在o(log(n))的复杂度内完成,而dict中存储的主要是<key,score>的键值对，他能是的zscore这种操作能在O(1)的复杂度内完成。 数据结构 下面的代码即为zset的数据结构 //跳表每个节点的结构 typedef struct zskiplistNode { sds
Redis源码剖析 有序集合对象t_zset实现
harleylau的博客
03-28 560
有序集合对象其实跟集合对象类似，只不过它多了一个score的参数，集合中的每个元素都有一个分值，在集合中元素是按照score排序的。 有序集合的底层编码也是有两种实现，压缩列表REDIS_ENCODING_ZIPLIST以及跳跃表REDIS_ENCODING_SKIPLIST。和集合的一样，有序集合的编码方式是通过检查第一个被加入的元素来决定的。 ZSET结构 /* RedisObject结构...
基于redis的zset实现排行榜功能
热门推荐
lunwuciyu的专栏
09-27 3万+
基于redis的zset实现排行榜功能
redis zset 跳表
07-30
Redis中的有序集合（zset）使用跳跃表（skiplist）作为底层数据结构来实现。跳跃表是一种有序集合的数据结构，它的效率可以媲美红黑树，但实现起来比红黑树简单。跳跃表由多层链表组成，每一层都是一个有序的链表，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值