Redis数据结构底层实现

时间 2021-06-22

标签 redis 算法数据库数组服务器微信数据结构函数优化栏目 Redis 繁體版

原文原文链接

记得点赞+关注呦。

前言

Redis 有五种基本数据类型，但是你们知道这五种数据类型的底层是咋实现吗？接下就带你们了解一下 String、List、Hash、Set、Sorted Set 底层是如何实现的，在这以前，先来看下下面的基本数据结构，分别有简单动态字符串(SDS)、链表、字典、跳跃表、整数集合以及压缩列表，它们是Redis数据结构的基本组成部分。redis

五种数据结构底层实现

1. String算法

若是一个字符串对象保存的是整数值，而且这个整数值能够用 long 类型来表示，那么字符串对象会将整数值保存在字符串对象结构的 ptr 属性里面（将 void* 转换成 long ），并将字符串对象的编码设置为 int 。
若是字符串对象保存的是一个字符串值，而且这个字符串值的长度大于 39 字节，那么字符串对象将使用一个简单动态字符串（SDS）来保存这个字符串值，并将对象的编码设置为 raw。
若是字符串对象保存的是一个字符串值，而且这个字符串值的长度小于等于 39 字节，那么字符串对象将使用 embstr 编码的方式来保存这个字符串值。

2. List数据库

列表对象的编码能够是 ziplist 或者 linkedlist 。
列表对象保存的全部字符串元素的长度都小于 64 字节而且保存的元素数量小于 512 个，使用 ziplist 编码；不然使用 linkedlist；

3. Hash数组

哈希对象的编码能够是 ziplist 或者 hashtable 。
哈希对象保存的全部键值对的键和值的字符串长度都小于 64 字节而且保存的键值对数量小于 512 个，使用ziplist 编码；不然使用hashtable；

4. Set服务器

集合对象的编码能够是 intset 或者 hashtable 。
集合对象保存的全部元素都是整数值而且保存的元素数量不超过 512 个，使用intset 编码；不然使用hashtable；

5. Sorted Set微信

有序集合的编码能够是 ziplist 或者 skiplist
有序集合保存的元素数量小于 128 个而且保存的全部元素成员的长度都小于 64 字节。使用 ziplist 编码；不然使用skiplist；

接下来分别说说这些底层数据结构。数据结构

1、简单动态字符串（SDS）

Redis 本身构建了一种名为简单动态字符串（simple dynamic string，SDS）的抽象类型，并将 SDS 用做 Redis 的默认字符串表示。如：函数

set msg "hello world"

key 和 value 底层都是用 SDS 来实现的。
SDS 的结构：优化

struct sdshdr {

    // 记录 buf 数组中已使用字节的数量
    // 等于 SDS 所保存字符串的长度
    int len;

    // 记录 buf 数组中未使用字节的数量
    int free;

    // 字节数组，用于保存字符串
    char buf[];

};

free 属性的值为 0 ，表示这个 SDS 没有分配任何未使用空间。
len 属性的值为 5 ，表示这个 SDS 保存了一个五字节长的字符串。
buf 属性是一个 char 类型的数组，数组的前五个字节分别保存了 'R' 、 'e' 、 'd' 、 'i' 、 's' 五个字符，而最后一个字节则保存了空字符 '\0' 。

SDS 与 C 语言字符串比较相近，但拥有更过的优点：ui

1. SDS 获取字符串长度时间复杂度O(1)：由于 SDS 经过 len 字段来存储长度，使用时直接读取就能够；C 语言要想获取字符串长度须要遍历整个字符串，时间复杂度O(N)。
2. SDS 能杜绝缓冲区的溢出：由于当 SDS API 要对 SDS 进行修改时，会先检查 SDS 的空间是否足够，若是不够的话 SDS 会自动扩容，So，不会形成缓冲区溢出。而 C 语言则不剧本这个功能。
3. SDS 能减小修改字符串时带来的内存重分配次数：  
    - 空间预分配：当SDS 扩容时不仅是会增长须要的空间大小，还会额外的分配一些未使用的空间。分配的规则是：若是分配后SDS的长度小于 1MB，那么会分配等于分配后SDS 的大小的未使用空间，简单说就是，SDS 动态分配后是 16KB，那么就会多分配 16KB 的未使用空间；若是 小于 1MB，那么久分配 1MB 的未使用空间。  
    - 惰性空间释放： 惰性空间释放用于优化 SDS 的字符串缩短操做：当 SDS 的 API 须要缩短 SDS 保存的字符串时，并不会当即内存重分配来回收多出来的字节，而是用 free 来记录未使用空间。

2、链表

链表提供了高效的节点重排能力，以及顺序性的节点访问方式，而且能够经过增删节点来灵活地调整链表的长度。链表在 Redis 中的应用很是普遍，好比 List 的底层实现之一链表，当一个 List 包含了数量比较多的元素，又或者列表中包含的元素都是比较长的字符串时，Redis 就会使用链表做为 List 的底层实现。除了用做 List 的底层实现以外，发布与订阅、慢查询、监视器等动能也用到了链表， Redis 服务器自己还使用链表来保存多个客户端的状态信息，以及使用链表来构建客户端输出缓冲区。
每一个链表节点使用一个 adlist.h/listNode 结构来表示：

typedef struct listNode {

    // 前置节点
    struct listNode *prev;

    // 后置节点
    struct listNode *next;

    // 节点的值
    void *value;

} listNode;

多个 listNode 能够经过 prev 和 next 指针组成双端链表，以下图所示。

虽然仅仅使用多个 listNode 结构就能够组成链表，但使用 adlist.h/list 来持有链表的话，操做起来会更方便：

typedef struct list {

    // 表头节点
    listNode *head;

    // 表尾节点
    listNode *tail;

    // 链表所包含的节点数量
    unsigned long len;

    // 节点值复制函数
    void *(*dup)(void *ptr);

    // 节点值释放函数
    void (*free)(void *ptr);

    // 节点值对比函数
    int (*match)(void *ptr, void *key);

} list;

list 结构为链表提供了表头指针 head 、表尾指针 tail ，以及链表长度计数器 len ，而 dup 、 free 和 match 成员则是用于实现多态链表所需的类型特定函数：

dup 函数用于复制链表节点所保存的值；
free 函数用于释放链表节点所保存的值；
match 函数则用于对比链表节点所保存的值和另外一个输入值是否相等。
下图是由一个 list 结构和三个 listNode 结构组成的链表：

Redis 的链表实现的特性能够总结以下：
双端：链表节点带有 prev 和 next 指针，获取某个节点的前置节点和后置节点的复杂度都是 O(1) 。
无环：表头节点的 prev 指针和表尾节点的 next 指针都指向 NULL ，对链表的访问以 NULL 为终点。
带表头指针和表尾指针：经过 list 结构的 head 指针和 tail 指针，程序获取链表的表头节点和表尾节点的复杂度为 O(1) 。
带链表长度计数器：程序使用 list 结构的 len 属性来对 list 持有的链表节点进行计数，程序获取链表中节点数量的复杂度为 O(1) 。
多态：链表节点使用 void* 指针来保存节点值，而且能够经过 list 结构的 dup 、 free 、 match 三个属性为节点值设置类型特定函数，因此链表能够用于保存各类不一样类型的值。
3、字典
字典，又称符号表（symbol table）、关联数组（associative array）或者映射（map），是一种用于保存键值对（key-value pair）的抽象数据结构。其中 Key 是惟一的。相似 Java 的 Map。
字典在 Redis 中主要被应用与：
Redis 数据库底层就是用字典实现的，对数据库的增、删、改、查操做都是构建在对字典的操做之上，好比：
```
> set msg "hello world"
OK
```
这个就是建立一个 key 为 "msg"，value 为 "hello world" 的键值对，保存在表明数据库的字典中。
字典仍是哈希键的底层实现之一：当一个哈希键包含的键值对比较多，又或者键值对中的元素都是比较长的字符串时， Redis 就会使用字典做为哈希键的底层实现。

Redis 的字典使用哈希表做为底层实现，一个哈希表里面能够有多个哈希表节点，而每一个哈希表节点就保存了字典中的一个键值对。
接下来的三个小节将分别介绍 Redis 的哈希表、哈希表节点、以及字典的实现。

哈希表

Redis 字典所使用的哈希表由 dict.h/dictht 结构定义：

typedef struct dictht {

    // 哈希表数组
    dictEntry **table;

    // 哈希表大小
    unsigned long size;

    // 哈希表大小掩码，用于计算索引值
    // 老是等于 size - 1
    unsigned long sizemask;

    // 该哈希表已有节点的数量
    unsigned long used;

} dictht;

table 属性是一个数组，数组中的每一个元素都是一个指向 dict.h/dictEntry 结构的指针，每一个 dictEntry 结构保存着一个键值对。

size 属性记录了哈希表的大小，也便是 table 数组的大小，而 used 属性则记录了哈希表目前已有节点（键值对）的数量。

sizemask 属性的值老是等于 size - 1 ，这个属性和哈希值一块儿决定一个键应该被放到 table 数组的哪一个索引上面。

下图展现了一个大小为 4 的空哈希表（没有包含任何键值对）。

哈希节点

哈希表节点使用 dictEntry 结构表示，每一个 dictEntry 结构都保存着一个键值对：

typedef struct dictEntry {

    // 键
    void *key;

    // 值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
    } v;

    // 指向下个哈希表节点，造成链表
    struct dictEntry *next;

} dictEntry;

key 属性保存着键值对中的键，而 v 属性则保存着键值对中的值，其中键值对的值能够是一个指针，或者是一个 uint64_t 整数，又或者是一个 int64_t 整数。

next 属性是指向另外一个哈希表节点的指针，这个指针能够将多个哈希值相同的键值对链接在一次，以此来解决键冲突（collision）的问题。

举个例子，下图就展现了如何经过 next 指针，将两个索引值相同的键 k1 和 k0 链接在一块儿。

字典

Redis 中的字典由 dict.h/dict 结构表示：

typedef struct dict {

    // 类型特定函数
    dictType *type;

    // 私有数据
    void *privdata;

    // 哈希表
    dictht ht[2];

    // rehash 索引
    // 当 rehash 不在进行时，值为 -1
    int rehashidx; /* rehashing not in progress if rehashidx == -1 */

} dict;

type 属性和 privdata 属性是针对不一样类型的键值对，为建立多态字典而设置的：

type 属性是一个指向 dictType 结构的指针，每一个 dictType 结构保存了一簇用于操做特定类型键值对的函数， Redis 会为用途不一样的字典设置不一样的类型特定函数。
而 privdata 属性则保存了须要传给那些类型特定函数的可选参数。

ht 属性是一个包含两个项的数组，数组中的每一个项都是一个 dictht 哈希表，通常状况下，字典只使用 ht[0] 哈希表， ht[1] 哈希表只会在对 ht[0] 哈希表进行 rehash 时使用。

除了 ht[1] 以外，另外一个和 rehash 有关的属性就是 rehashidx ：它记录了 rehash 目前的进度，若是目前没有在进行 rehash ，那么它的值为 -1 。

下图展现了一个普通状态下（没有进行 rehash）的字典：

哈希算法

当将一个新的键值对插入到字典中，须要计算索引值，Redis 计算索引值的方法是：

# 使用字典设置的哈希函数，计算键 key 的哈希值
hash = dict->type->hashFunction(key);

# 使用哈希表的 sizemask 属性和哈希值，计算出索引值
# 根据状况不一样， ht[x] 能够是 ht[0] 或者 ht[1]
index = hash & dict->ht[x].sizemask;

相似 Java 的HashMap，计算 key 的 hash 值，而后 hash & (len - 1), 而 Redis 的 sizemask 就是 size - 1。

哈希冲突怎么办

当出现 Hash 冲突时，Redis 使用的是链地址法来解决冲突，链地址法就是将冲突的节点构成一个链表放在该索引位置上，Redis 采用的是头插法。解决hash冲突的还有三种方法，分别是：开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）、再哈希法以及创建一个公共溢出区，之后会单独介绍一些解决hash冲突的四种方法。

rehash

随着不断的操做，hash表中的键值对可能会增多或减小，为了让哈希表的负载因子保持在一个范围内，须要对 hash表进行扩容或收缩，收缩和扩容的过程就叫 rehash。rehash 过程以下：

为字典的 ht[1] 哈希表分配空间，这个哈希表的空间大小取决于要执行的操做，以及 ht[0] 当前包含的键值对数量（也便是 ht[0].used 属性的值）(ht 是字典中的 hash 表，上文有介绍)：
- 若是执行的是扩展操做，那么 ht[1] 的大小为第一个大于等于 ht[0].used * 2 的 2^n （2 的 n 次方幂）；
- 若是执行的是收缩操做，那么 ht[1] 的大小为第一个大于等于 ht[0].used 的 2^n 。
将保存在 ht[0] 中的全部键值对 rehash 到 ht[1] 上面： rehash 指的是从新计算键的哈希值和索引值，而后将键值对放置到 ht[1] 哈希表的指定位置上。
当 ht[0] 包含的全部键值对都迁移到了 ht[1] 以后（ht[0] 变为空表），释放 ht[0] ，将 ht[1] 设置为 ht[0] ，并在 ht[1] 新建立一个空白哈希表，为下一次 rehash 作准备

当如下条件中的任意一个被知足时，程序会自动开始对哈希表执行扩展操做：

服务器目前没有在执行 BGSAVE 命令或者 BGREWRITEAOF 命令，而且哈希表的负载因子大于等于 1 ；
服务器目前正在执行 BGSAVE 命令或者 BGREWRITEAOF 命令，而且哈希表的负载因子大于等于 5 ；
其中哈希表的负载因子能够经过公式：

# 负载因子 = 哈希表已保存节点数量 / 哈希表大小  
load_factor = ht[0].used / ht[0].size

计算得出。

好比说，对于一个大小为 4 ，包含 4 个键值对的哈希表来讲，这个哈希表的负载因子为：

load_factor = 4 / 4 = 1
又好比说，对于一个大小为 512 ，包含 256 个键值对的哈希表来讲，这个哈希表的负载因子为：

load_factor = 256 / 512 = 0.5
根据 BGSAVE 命令或 BGREWRITEAOF 命令是否正在执行，服务器执行扩展操做所需的负载因子并不相同，这是由于在执行 BGSAVE 命令或 BGREWRITEAOF 命令的过程当中， Redis 须要建立当前服务器进程的子进程，而大多数操做系统都采用写时复制（copy-on-write）技术来优化子进程的使用效率，因此在子进程存在期间，服务器会提升执行扩展操做所需的负载因子，从而尽量地避免在子进程存在期间进行哈希表扩展操做，这能够避免没必要要的内存写入操做，最大限度地节约内存。

另外一方面，当哈希表的负载因子小于 0.1 时，程序自动开始对哈希表执行收缩操做。

渐进式 rehash

rehash 时会将 ht[0] 全部的键值对迁移到 ht[1] 中，但这个动做不是一次性的，而是分屡次、渐进式地完成。这样的所得缘由时：当数据量大的时候一次性迁移会形成服务器在一段时间内定制服务。为了不发生这样的事就出现了 渐进式rehash。
如下是哈希表渐进式 rehash 的详细步骤：
1) 为 ht[1] 分配空间，让字典同时持有 ht[0] 和 ht[1] 两个哈希表。
2) 在字典中维持一个索引计数器变量 rehashidx ，并将它的值设置为 0 ，表示 rehash 工做正式开始。
3) 在 rehash 进行期间，每次对字典执行添加、删除、查找或者更新操做时，程序除了执行指定的操做之外，还会顺带将 ht[0] 哈希表在 rehashidx 索引上的全部键值对 rehash 到 ht[1] ，当 rehash 工做完成以后，程序将 rehashidx 属性的值增一。
4) 随着字典操做的不断执行，最终在某个时间点上， ht[0] 的全部键值对都会被 rehash 至 ht[1] ，这时程序将 rehashidx 属性的值设为 -1 ，表示 rehash 操做已完成。

渐进式 rehash 的好处在于它采起分而治之的方式，将 rehash 键值对所需的计算工做均滩到对字典的每一个添加、删除、查找和更新操做上，从而避免了集中式 rehash 而带来的庞大计算量。在 rehash 期间，字典的删改查操做都是同时做用在 ht[0] 以及 ht[1] 上的。如查找一个键，会如今 ht[0] 查找，找不到就去 ht[1] 查找，注意的是增长操做，新增的键值对只会保存到 ht[1]上，不会保存到 ht[0] 上，这一措施保证了 ht[0] 的键值只减不增，随着 rehash 操做 ht[0] 最终会变成空表。

Redis 的字典实现的特性能够总结以下：

字典被普遍用于实现 Redis 的各类功能，其中包括数据库和哈希键。
Redis 中的字典使用哈希表做为底层实现，每一个字典带有两个哈希表，一个用于平时使用，另外一个仅在进行 rehash 时使用。
当字典被用做数据库的底层实现，或者哈希键的底层实现时， Redis 使用 MurmurHash2 算法来计算键的哈希值。
哈希表使用链地址法来解决键冲突，被分配到同一个索引上的多个键值对会链接成一个单向链表。
在对哈希表进行扩展或者收缩操做时，程序须要将现有哈希表包含的全部键值对 rehash 到新哈希表里面，而且这个 rehash 过程并非一次性地完成的，而是渐进式地完成的。

4、跳跃表

跳跃表（skiplist）是一种有序数据结构，它经过在每一个节点中维持多个指向其余节点的指针，从而达到快速访问节点的目的。
跳跃表支持平均 O(\log N) 最坏 O(N) 复杂度的节点查找，还能够经过顺序性操做来批量处理节点。

在大部分状况下，跳跃表的效率能够和平衡树相媲美，而且由于跳跃表的实现比平衡树要来得更为简单，因此有很多程序都使用跳跃表来代替平衡树。

Redis 使用跳跃表做为有序集合键的底层实现之一：若是一个有序集合包含的元素数量比较多，又或者有序集合中元素的成员（member）是比较长的字符串时，Redis 就会使用跳跃表来做为有序集合键的底层实现。

Redis 只在两个地方用到了跳跃表，一个是实现有序集合键，另外一个是在集群节点中用做内部数据结构，除此以外，跳跃表在 Redis 里面没有其余用途。

Redis 的跳跃表由 redis.h/zskiplistNode 和 redis.h/zskiplist 两个结构定义，其中 zskiplistNode 结构用于表示跳跃表节点，而 zskiplist 结构则用于保存跳跃表节点的相关信息，好比节点的数量，以及指向表头节点和表尾节点的指针，等等。

上图展现了一个跳跃表示例，位于图片最左边的是 zskiplist 结构，该结构包含如下属性：

header ：指向跳跃表的表头节点。
tail ：指向跳跃表的表尾节点。
level ：记录目前跳跃表内，层数最大的那个节点的层数（表头节点的层数不计算在内）。
length ：记录跳跃表的长度，也便是，跳跃表目前包含节点的数量（表头节点不计算在内）。

位于 zskiplist 结构右方的是四个 zskiplistNode 结构，该结构包含如下属性：

层（level）：节点中用 L1 、 L2 、 L3 等字样标记节点的各个层， L1 表明第一层， L2 表明第二层，以此类推。每一个层都带有两个属性：前进指针和跨度。前进指针用于访问位于表尾方向的其余节点，而跨度则记录了前进指针所指向节点和当前节点的距离。在上面的图片中，连线上带有数字的箭头就表明前进指针，而那个数字就是跨度。当程序从表头向表尾进行遍历时，访问会沿着层的前进指针进行。
后退（backward）指针：节点中用 BW 字样标记节点的后退指针，它指向位于当前节点的前一个节点。后退指针在程序从表尾向表头遍历时使用。
分值（score）：各个节点中的 1.0 、 2.0 和 3.0 是节点所保存的分值。在跳跃表中，节点按各自所保存的分值从小到大排列。
成员对象（obj）：各个节点中的 o1 、 o2 和 o3 是节点所保存的成员对象。

注意表头节点和其余节点的构造是同样的：表头节点也有后退指针、分值和成员对象，不过表头节点的这些属性都不会被用到，因此图中省略了这些部分，只显示了表头节点的各个层。

本节接下来的内容将对 zskiplistNode 和 zskiplist 两个结构进行更详细的介绍。

跳跃表节点

跳跃表节点的实现由 redis.h/zskiplistNode 结构定义：

typedef struct zskiplistNode {

    // 后退指针
    struct zskiplistNode *backward;

    // 分值
    double score;

    // 成员对象
    robj *obj;

    // 层
    struct zskiplistLevel {

        // 前进指针
        struct zskiplistNode *forward;

        // 跨度
        unsigned int span;

    } level[];

} zskiplistNode;

层
跳跃表节点的 level 数组能够包含多个元素，每一个元素都包含一个指向其余节点的指针，程序能够经过这些层来加快访问其余节点的速度，通常来讲，层的数量越多，访问其余节点的速度就越快。

每次建立一个新跳跃表节点的时候，程序都根据幂次定律（power law，越大的数出现的几率越小）随机生成一个介于 1 和 32 之间的值做为 level 数组的大小，这个大小就是层的“高度”。

下图分别展现了三个高度为 1 层、 3 层和 5 层的节点，由于 C 语言的数组索引老是从 0 开始的，因此节点的第一层是 level[0] ，而第二层是 level[1] ，以此类推。

跨度
层的跨度（level[i].span 属性）用于记录两个节点之间的距离：

两个节点之间的跨度越大，它们相距得就越远。
指向 NULL 的全部前进指针的跨度都为 0 ，由于它们没有连向任何节点。
初看上去，很容易觉得跨度和遍历操做有关，但实际上并非这样 —— 遍历操做只使用前进指针就能够完成了，跨度其实是用来计算排位（rank）的：在查找某个节点的过程当中，将沿途访问过的全部层的跨度累计起来，获得的结果就是目标节点在跳跃表中的排位。

举个例子，下图用虚线标记了在跳跃表中查找分值为 3.0 、成员对象为 o3 的节点时，沿途经历的层：查找的过程只通过了一个层，而且层的跨度为 3 ，因此目标节点在跳跃表中的排位为 3 。

后退指针
节点的后退指针（backward 属性）用于从表尾向表头方向访问节点：跟能够一次跳过多个节点的前进指针不一样，由于每一个节点只有一个后退指针，因此每次只能后退至前一个节点。

下图用虚线展现了若是从表尾向表头遍历跳跃表中的全部节点：程序首先经过跳跃表的 tail 指针访问表尾节点，而后经过后退指针访问倒数第二个节点，以后再沿着后退指针访问倒数第三个节点，再以后遇到指向 NULL 的后退指针，因而访问结束。

分值和成员

节点的分值（score 属性）是一个 double 类型的浮点数，跳跃表中的全部节点都按分值从小到大来排序。

节点的成员对象（obj 属性）是一个指针，它指向一个字符串对象，而字符串对象则保存着一个 SDS 值。

在同一个跳跃表中，各个节点保存的成员对象必须是惟一的，可是多个节点保存的分值却能够是相同的：分值相同的节点将按照成员对象在字典序中的大小来进行排序，成员对象较小的节点会排在前面（靠近表头的方向），而成员对象较大的节点则会排在后面（靠近表尾的方向）。

举个例子，在下图所示的跳跃表中，三个跳跃表节点都保存了相同的分值 10086.0 ，但保存成员对象 o1 的节点却排在保存成员对象 o2 和 o3 的节点以前，而保存成员对象 o2 的节点又排在保存成员对象 o3 的节点以前，因而可知， o1 、 o2 、 o3 三个成员对象在字典中的排序为 o1 <= o2 <= o3 。

跳跃表
虽然仅靠多个跳跃表节点就能够组成一个跳跃表，以下图所示。

但经过使用一个 zskiplist 结构来持有这些节点，程序能够更方便地对整个跳跃表进行处理，好比快速访问跳跃表的表头节点和表尾节点，又或者快速地获取跳跃表节点的数量（也便是跳跃表的长度）等信息，以下图所示。

zskiplist 结构的定义以下：

typedef struct zskiplist {

    // 表头节点和表尾节点
    struct zskiplistNode *header, *tail;

    // 表中节点的数量
    unsigned long length;

    // 表中层数最大的节点的层数
    int level;

} zskiplist;

header 和 tail 指针分别指向跳跃表的表头和表尾节点，经过这两个指针，程序定位表头节点和表尾节点的复杂度为 O(1) 。

经过使用 length 属性来记录节点的数量，程序能够在 O(1) 复杂度内返回跳跃表的长度。

level 属性则用于在 O(1) 复杂度内获取跳跃表中层高最大的那个节点的层数量，注意表头节点的层高并不计算在内。

关于跳跃表的总结：

跳跃表是有序集合的底层实现之一，除此以外它在 Redis 中没有其余应用。
Redis 的跳跃表实现由 zskiplist 和 zskiplistNode 两个结构组成，其中 zskiplist 用于保存跳跃表信息（好比表头节点、表尾节点、长度），而 zskiplistNode 则用于表示跳跃表节点。
每一个跳跃表节点的层高都是 1 至 32 之间的随机数。
在同一个跳跃表中，多个节点能够包含相同的分值，但每一个节点的成员对象必须是惟一的。
跳跃表中的节点按照分值大小进行排序，当分值相同时，节点按照成员对象的大小进行排序。

5、整数集合

整数集合（intset）是集合键的底层实现之一：当一个集合只包含整数值元素，而且这个集合的元素数量很少时， Redis 就会使用整数集合做为集合键的底层实现。

举个例子，若是咱们建立一个只包含五个元素的集合键，而且集合中的全部元素都是整数值，那么这个集合键的底层实现就会是整数集合：

redis> SADD numbers 1 3 5 7 9
(integer) 5

redis> OBJECT ENCODING numbers
"intset"

整数集合（intset）是 Redis 用于保存整数值的集合抽象数据结构，它能够保存类型为 int16_t 、 int32_t 或者 int64_t 的整数值，而且保证集合中不会出现重复元素。

每一个 intset.h/intset 结构表示一个整数集合：

typedef struct intset {

    // 编码方式
    uint32_t encoding;

    // 集合包含的元素数量
    uint32_t length;

    // 保存元素的数组
    int8_t contents[];

} intset;

contents 数组是整数集合的底层实现：整数集合的每一个元素都是 contents 数组的一个数组项（item），各个项在数组中按值的大小从小到大有序地排列，而且数组中不包含任何重复项。

length 属性记录了整数集合包含的元素数量，也便是 contents 数组的长度。

虽然 intset 结构将 contents 属性声明为 int8_t 类型的数组，但实际上 contents 数组并不保存任何 int8_t 类型的值 —— contents 数组的真正类型取决于 encoding 属性的值：若是 encoding 属性的值为 INTSET_ENC_INT16 ，那么 contents 就是一个 int16_t 类型的数组，数组里的每一个项都是一个 int16_t 类型的整数值（最小值为 -32,768 ，最大值为 32,767 ）。
下图是一个包含五个int16_t类型整数值的整数集合。

每当咱们要将一个新元素添加到整数集合里面，而且新元素的类型比整数集合现有全部元素的类型都要长时，整数集合须要先进行升级（upgrade），而后才能将新元素添加到整数集合里面。

升级整数集合并添加新元素共分为三步进行：

根据新元素的类型，扩展整数集合底层数组的空间大小，并为新元素分配空间。
将底层数组现有的全部元素都转换成与新元素相同的类型，并将类型转换后的元素放置到正确的位上，并且在放置元素的过程当中，须要继续维持底层数组的有序性质不变。
将新元素添加到底层数组里面。

整数集合不支持降级操做，一旦对数组进行了升级，编码就会一直保持升级后的状态。

关于整数集合的总结：

整数集合是集合键的底层实现之一。
整数集合的底层实现为数组，这个数组以有序、无重复的方式保存集合元素，在有须要时，程序会根据新添加元素的类型，改变这个数组的类型。
升级操做为整数集合带来了操做上的灵活性，而且尽量地节约了内存。
整数集合只支持升级操做，不支持降级操做。

6、压缩列表

压缩列表（ziplist）是列表键和哈希键的底层实现之一。

当一个列表键只包含少许列表项，而且每一个列表项要么就是小整数值，要么就是长度比较短的字符串，那么 Redis 就会使用压缩列表来作列表键的底层实现。

好比说，执行如下命令将建立一个压缩列表实现的列表键：

redis> RPUSH lst 1 3 5 10086 "hello" "world"
(integer) 6

redis> OBJECT ENCODING lst
"ziplist"

由于列表键里面包含的都是 1 、 3 、 5 、 10086 这样的小整数值，以及 "hello" 、 "world" 这样的短字符串。

另外，当一个哈希键只包含少许键值对，而且每一个键值对的键和值要么就是小整数值，要么就是长度比较短的字符串，那么 Redis 就会使用压缩列表来作哈希键的底层实现。

举个例子，执行如下命令将建立一个压缩列表实现的哈希键：

redis> HMSET profile "name" "Jack" "age" 28 "job" "Programmer"
OK

redis> OBJECT ENCODING profile
"ziplist"

由于哈希键里面包含的全部键和值都是小整数值或者短字符串。
压缩列表的构成:
压缩列表是 Redis 为了节约内存而开发的，由一系列特殊编码的连续内存块组成的顺序型（sequential）数据结构。

一个压缩列表能够包含任意多个节点（entry），每一个节点能够保存一个字节数组或者一个整数值。

下图展现了压缩列表的各个组成部分。

下表则记录了各个组成部分的类型、长度、以及用途。表 7-1 则记录了各个组成部分的类型、长度、以及用途。

属性	类型	长度	用途
zlbytes	uint32_t	4 字节	记录整个压缩列表占用的内存字节数：在对压缩列表进行内存重分配，或者计算 zlend 的位置时使用。

zltail	uint32_t	4 字节	记录压缩列表表尾节点距离压缩列表的起始地址有多少字节：经过这个偏移量，程序无须遍历整个压缩列表就能够肯定表尾节点的地址。
zllen	uint16_t	2 字节	记录了压缩列表包含的节点数量：当这个属性的值小于 UINT16_MAX （65535）时，这个属性的值就是压缩列表包含节点的数量；当这个值等于 UINT16_MAX 时，节点的真实数量须要遍历整个压缩列表才能计算得出。
entryX	列表节点	不定	压缩列表包含的各个节点，节点的长度由节点保存的内容决定。
zlend	uint8_t	1 字节	特殊值 0xFF （十进制 255 ），用于标记压缩列表的末端。

压缩列表节点的构成:
每一个压缩列表节点都由 previous_entry_length 、 encoding 、 content 三个部分组成，以下图所示。

节点的 previous_entry_length 属性以字节为单位，记录了压缩列表中前一个节点的长度。
节点的 encoding 属性记录了节点的 content 属性所保存数据的类型以及长度：
节点的 content 属性负责保存节点的值，节点值能够是一个字节数组或者整数，值的类型和长度由节点的 encoding 属性决定。
关于压缩列表的总结：
压缩列表是一种为节约内存而开发的顺序型数据结构。
压缩列表被用做列表键和哈希键的底层实现之一。
压缩列表能够包含多个节点，每一个节点能够保存一个字节数组或者整数值。
添加新节点到压缩列表，或者从压缩列表中删除节点，可能会引起连锁更新操做，但这种操做出现的概率并不高。
最后

若是以为还不错请点赞关注转发，不胜感激。

更多精彩内容微信搜素：蘑菇睡不着