渐进式解析 Redis 源码 - 压缩列表 ziplist

阅读量

压缩列表ziplist 是由一系列特殊编码的连续内存块组成的顺序型数据结构，即 将一系列数据与其编码信息存储在一块物理上连续的内存空间上，但是 逻辑上却是分作多个部分，其目的是在一定可控的时间复杂读条件下尽可能的减少不必要的内存开销，从而达到节省内存的效果

Redis 中 压缩列表 是 列表键和哈希键 的底层实现之一，当一个 列表键只包含少量列表项 并且每个列表项 要么是比较小的整数值或者比较短的字符串 的时候，那么就会使用 压缩列表进行表示，同理 哈希键的情况也是一样的

压缩列表 的实现原理主要体现在 编码 这个词上，所以我们后续更多以 编码 角度去解读…

压缩列表结构

一个压缩列表是一段连续的内存空间，往往包含 zlbytes( 压缩表占用空间数据 ) + zltail( 表尾数据记录 ) + zllen( 表长 ) + entry( 若干个节点 ) + zlend( 特殊标识 )

redis 压缩列表结构

  • zlbytes uint32_t 类型，4 字节，记录整个压缩列表占用的内存字节数
  • zltail uint32_t 类型，4 字节，记录压缩列表 起始位置节点距离尾节点地址 的距离 有多少字节
  • zllen uint16_t 类型，2 字节，压缩列表 节点数量，当属性值小于 uint16_t 最大数 65535 的时候代表 节点数量，如果等于这个值，真实节点数量就只能遍历整个列表才能得出了
  • entry 节点，整个压缩列表可能存储若干个节点
  • zlend uint8_t 类型，1 字节，存储特殊值0xFF ( =255 ) ，用于标记压缩列表尾端

比如 一个压缩列表 示例：

zlbytes 值 0xd2 ( =210 )，表示压缩列表长度为 210字节
zltail 值 0xb3( =179 )，表示从 压缩列表起始地址指针 + 179字节 就表示最后一个节点的指针地址
zllen 值 0x5 ( =5 )，表示有 5个节点

压缩列表节点结构

压缩列表节点的结构体内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct zlentry {
    // 前一个节点的长度
    unsigned int prevrawlensize;
    // 前一个节点编码所需长度
    unsigned int prevrawlen;
    // 当前节点长度
    unsigned int lensize;
    // 当前节点编码所需长度
    unsigned int len;
    // 头的大小
    unsigned int headersize;
    // 编码类型
    unsigned char encoding;
    // 字节指针
    unsigned char *p;
} zlentry;

首先我们需要知道前提要点，那就是 每个节点都有可能存储的是 一个字节数组 或者 一个整数值

  • 字节数组长度一般要求长度在如下三种范围内
    • <= 63 ( 26 - 1 )
    • <= 16 383 ( 214 - 1 )
    • <= 4 294 967 295 ( 232 - 1 )
  • 整数值 大小一般要求在如下三种范围内
    • 4位 长度 的无符号整数
    • 1 字节长度的有符号整数
    • 3 字节长度的有符号整数
    • int16_t 类型整数
    • int32_t 类型整数
    • int64_t 类型整数

然后我们一块看看 节点的 三个组成元素：

  • previous_entry_length 记录了前一个节点的长度，即 当前节点指针地址 - previous_entry_length = 前一个节点指针地址，压缩列表的逆向遍历就是用这一方法实现的
    • 如果前一个节点的长度小于 254 字节，那么 previous_entry_length 属性的长度为 1 字节，前一个节点的长度就保存在这个字节里； 例如，previous_entry_length 属性的值为 0x00000005，那么代表 前一个节点的长度为 5
    • 如果前一个节点的长度大于等于 254 字节，那么 previous_entry_length 属性的长度为 5 字节，不过 其中第 1个字节为 0xFE( =254 ) ，之后 4个直接 用来保存前一个节点的 长度；例如，previous_entry_length 属性的值为 0xFE00001233，那么代表 前一个节点的长度为 0x00001233 = 4659 字节
  • encoding 记录了节点 content 属性所保存数据的类型以及长度
    • 1 字节、2 字节、5 字节 长度的情况下，而且属性值最高位分别为 00、01、10 开头的为字符数组编码，这种编码表示字节的 content 属性保存着字符数组，数组的长度由编码除去最高两位之后其他位记录；下面我们来进行示例一下各种长度的字符串的情况，下方 b、x、a 等表示占位二进制数据，_ 表示留空
      • 00bbbbbb 共 1 字节，表示长度小于等于 63 字节的字符数组
      • 01bbbbbb xxxxxxxx 共 2 字节，表示长度小于等于 16 383 字节的字符数组
      • 10______ aaaaaaaa bbbbbbbb cccccccc dddddddd 共 5 字节，表示长度小于等于 4 294 967 295 字节的字符数组
    • 1 字节长 而且 属性值最高位为 11 开头的代表是 整数编码，这种编码表示字节的 content 属性保存着整数值，整数值类型和长度由 编码除去最高两位之后其他位记录；下面我们来进行示例一下各种长度的整数的情况
      • 11000000 共 1 字节，代表 content 保存 int16_t 类型的整数
      • 11010000 共 1 字节，代表 content 保存 int32_t 类型的整数
      • 11100000 共 1 字节，代表 content 保存 int64_t 类型的整数
      • 11110000 共 1 字节，代表 content 保存 24 位有符号整数
      • 11111110 共 1 字节，代表 content 保存 8 位有符号整数
      • 1111xxxx 共 1 字节，使用这一编码的的节点 content 不保存属性，因为 xxxx 已经能代表 0 ~ 12 的值，所以不需要保存在 content 属性里面
  • content 保存了节点的值内容，节点的值可以是 字符数组或者 整数，值的类型和长度 由节点的 encoding 属性确定

例如，节点的值为 字符数组 “hello wettper”，长度为 13，那么各种属性存储的是：
content 存储 “hello wettper”
encoding 存储 00001101
下一个节点的 previous_entry_length 存储 0x0000000d

而又假如，节点的值为 整数 4659，那么各种属性存储的是：
content 存储 4659
encoding 存储 11000000，代表保存 int16_t 类型整数
下一个节点的 previous_entry_length 存储 0x00000001

下面我们就 Redis 压缩列表 一些典型的 API 进行解析~~~

源码解析

由于有些方法里的代码量比较大，我们这里按照 典型的代码片段进行解析，同志们可以根据文章提示的代码位置 和 代码里面的关键词 在源码中搜素，可能数据结构一些元素 看不太懂什么意思，没关系，先混个脸熟，后面看完回头再看过来就明白了

Redis 定义了多种宏 来定义 encoding值 和 判断 encoding 类型 （为了代码显示问题，特地把 define 前面的 # 去除了）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/* ziplist.c: line 204 */
// 字符串
// 00000000 长度小于等于 63 字节的字符数组
define ZIP_STR_06B (0 << 6)
// 01000000 长度小于等于 16 383 字节的字符数组
define ZIP_STR_14B (1 << 6)
// 10000000 长度小于等于 4 294 967 295 字节的字符数组
define ZIP_STR_32B (2 << 6)
// 整数
// 11000000 int16_t 类型的整数
define ZIP_INT_16B (0xc0 | 0<<4)
// 11010000 int32_t 类型的整数
define ZIP_INT_32B (0xc0 | 1<<4)
// 11100000 int64_t 类型的整数
define ZIP_INT_64B (0xc0 | 2<<4)
// 11110000 24 位有符号整数
define ZIP_INT_24B (0xc0 | 3<<4)
// 11111110 8 位有符号整数
define ZIP_INT_8B 0xfe
// 判断是否为 字符串
define ZIP_IS_STR(enc) (((enc) & ZIP_STR_MASK) < ZIP_STR_MASK)

另外还有一些获取各部分值的宏 （为了代码显示问题，特地把 define 前面的 # 去除了）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 取出 zlbytes 的值
define ZIPLIST_BYTES(zl)       (*((uint32_t*)(zl)))
// 取出 zltail 的值
define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
// 取出 zllen 的值
define ZIPLIST_LENGTH(zl)      (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))
// 返回 ziplist header 部分的长度，总是固定的 10 字节
define ZIPLIST_HEADER_SIZE     (sizeof(uint32_t)*2+sizeof(uint16_t))
// 返回到达 ziplist 第一个节点（表头）的地址
define ZIPLIST_ENTRY_HEAD(zl)  ((zl)+ZIPLIST_HEADER_SIZE)
// 返回到达 ziplist 最后一个节点（表尾）的地址
define ZIPLIST_ENTRY_TAIL(zl)  ((zl)+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)))
// 返回 ziplist 的末端，也即是 zlend 之前的地址
define ZIPLIST_ENTRY_END(zl)   ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)

ziplist 创建函数 ziplistNew()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* ziplist.c: line 578 */
unsigned char *ziplistNew(void) {
    // 空 ziplist 有 11 个 字节，头部占用 10 个直接，尾部 1 个字节
    unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
    // 申请内存空间
    unsigned char *zl = zmalloc(bytes);
    // 设定 ziplist 属性
    // 设定 ziplist 所占字节数，如果有必要进行大小端转换
    ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
    // 设定尾节点相对头部的偏移量
    ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
    // 设定 压缩表长度
    ZIPLIST_LENGTH(zl) = 0;
    // 设定尾部标识
    zl[bytes-1] = ZIP_END;
    return zl;
}

压缩表的插入函数主要有两个 ziplistPush() 和 ziplistInsert()，分别是 往压缩列表表尾或表头推入新节点 和 往压缩列表指定位置插入指定节点，最终使用的处理逻辑都是 __ziplistInsert()

节点插入分为两种情况，相关的逻辑也大不相同

  • 尾端插入，相对比较简单
    • 记录到达 ziplist 末端所需的偏移量（因为之后的内存重分配可能会改变 ziplist 的地址，因此记录偏移量而不是保存指针）
    • 根据新节点要保存的值，计算出编码这个值所需的空间大小以及编码它前一个节点的长度所需的空间大小，然后对 ziplist 进行内存重分配
    • 设置新节点的各项属性： pre_entry_length 、 encoding 、 length 和 content
    • 更新 ziplist 的各项属性，比如记录空间占用的 zlbytes ，到达表尾节点的偏移量 zltail ，以及记录节点数量的 zllen
  • 中途插入，比起上一条，由于可能引起一系列前方节点的变化（连锁更新），所以要复杂很多；假设我们要将一个新节点 new 添加到节点 prev 和 next 之间
    • 为新节点扩大 ziplist 的空间
    • 设置 new 节点的各项值
    • 新的 new 节点取代原来的 prev 节点， 成为了 next 节点的新前驱节点
    • 但是这个时候 next 节点的 pre_entry_length 信息还没有更新，存储的还是 prev 的长度信息，所以 next 节点 pre_entry_length 需要存储 new 节点的长度信息，但是这里就会出现一个问题，会出现三种情况：next 的 pre_entry_length 刚好够 new长度编码 (new 和 pre 长度编码都是一样的 1 或者 5 字节)、next 的 pre_entry_length 有 5 字节，但是 new 长度编码只需要 1 字节、next 的 pre_entry_length 有 1 字节，但是 new 长度编码需要 5 字节，如果是 前两种情况都还好，只需要直接存储，但是如果是 第三种 情况，则会引起 连锁更新：必须对 ziplist 进行内存重分配， 从而扩展 next 的空间，然而，因为 next 的空间长度改变了， 所以程序又必须检查 next 的后继节点 next+1 ， 看它的 pre_entry_length 能否编码 next 的新长度， 如果不能的话，程序又需要继续对 next+1 进行扩容… 这就是说， 在某个/某些节点的前面添加新节点之后， 程序必须沿着路径挨个检查后续的节点，是否满足新长度的编码要求， 直到遇到一个能满足要求的节点（如果有一个能满足，则这个节点之后的其他节点也满足）， 或者到达 ziplist 的末端 zlend 为止， 这种检查操作的复杂度为 O(N2)

不过对于 连锁更新，因为只有在新添加节点的后面有连续多个长度接近 254 的节点时， 这种连锁更新才会发生， 所以可以普遍地认为， 这种连锁更新发生的概率非常小， 在一般情况下， 将添加操作看成是 O(N) 复杂度也是可以的；执行完这三种情况的其中一种后， 程序更新 ziplist 的各项属性， 至此，添加操作完成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/* ziplist.c: line 743 */
// @param char zl 压缩列表
// @param char p  插入位置
// @param char s  插入元素
// @param int  slen 新元素长度
unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
    // 当前长度
    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
    unsigned int prevlensize, prevlen = 0;
    size_t offset;
    int nextdiff = 0;
    unsigned char encoding = 0;
    // 初始化一个值，防止空值警告
    long long value = 123456789;
    zlentry tail;
    /* Find out prevlen for the entry that is inserted. */
    // 获取上一个节点的长度以及编码长度
    // 如果不是结尾(0xff)代表不是空表
    if (p[0] != ZIP_END) {
        // 直接获取 上一个节点的长度 以及 上一个节点编码所需长度，获取逻辑我们上面已经做过介绍
        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
    } else {
        // 获取 尾节点地址
        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
        // 如果 ptail[0] 为 尾节点则 证明是 空表
        if (ptail[0] != ZIP_END) {
            // 计算尾节点长度
            prevlen = zipRawEntryLength(ptail);
        }
    }
    // 先尝试整数编码
    if (zipTryEncoding(s,slen,&value,&encoding)) {
        // 整数编码长度
        reqlen = zipIntSize(encoding);
    } else {
        // 字符数组方式编码长度
        reqlen = slen;
    }
    // 前一个节点的编码长度
    reqlen += zipStorePrevEntryLength(NULL,prevlen);
    // 当前节点的编码长度
    reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
    
    int forcelarge = 0;
    // 如果不是尾端插入，就需要判断 next 位置的 pre_entry_length 部分空间长度是否 足够存储新节点长度编码，并 获取 差多少空间
    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
    // 相差为 -4 代表需要扩展，显然是因为 原本为 1个字节 但是现在 需要 5个字节
    if (nextdiff == -4 && reqlen < 4) {
        nextdiff = 0;
        // 需要扩展
        forcelarge = 1;
    }
    
    // 存储p相对于列表zl的偏移地址，这里存储 偏移量而不是直接 指针地址，是因为可能 扩展空间而地址改变
    offset = p-zl;
    // 扩展空间，curlen 当前列表长度，reqlen 新节点长度，新节点后继节点header 偏移长度
    zl = ziplistResize(zl,curlen+reqlen+nextdiff);
    // p 新地址
    p = zl+offset;
    // 非表尾插入，需要重新计算表尾的偏移量
    if (p[0] != ZIP_END) {
        // 移动现有元素，为新元素的插入提供空间
        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
        // p+reqlen为新节点前置节点移动后的位置，将新节点的长度编码至前置节点
        if (forcelarge)
            zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
        else
            zipStorePrevEntryLength(p+reqlen,reqlen);
        // 更新列表尾相对于表头的偏移量，将新节点的长度算上
        ZIPLIST_TAIL_OFFSET(zl) =
            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
        // 如果新节点后面有多个节点，那么表尾的偏移量需要算上nextdiff的值
        zipEntry(p+reqlen, &tail);
        if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
            ZIPLIST_TAIL_OFFSET(zl) =
                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
        }
    } else {
        // 表尾插入，直接计算偏移量
        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
    }
    // 当nextdiff不为0时，表示需要新节点的后继节点对头部进行扩展
    if (nextdiff != 0) {
        offset = p-zl;
        // 需要对p所指向的机电header进行扩展更新，有可能会引起连锁更新
        zl = __ziplistCascadeUpdate(zl,p+reqlen);
        p = zl+offset;
    }
    // 将新节点前置节点的长度写入新节点的header
    p += zipStorePrevEntryLength(p,prevlen);
    // 将新节点的值长度写入新节点的header
    p += zipStoreEntryEncoding(p,encoding,slen);
    // 写入节点值
    if (ZIP_IS_STR(encoding)) {
        memcpy(p,s,slen);
    } else {
        zipSaveInteger(p,value,encoding);
    }
    // 更新列表节点计数
    ZIPLIST_INCR_LENGTH(zl,1);
    return zl;
}

获取压缩列表指定索引上的节点函数 ziplistIndex()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* ziplist.c: line 965 */
unsigned char *ziplistIndex(unsigned char *zl, int index) {
    unsigned char *p;
    unsigned int prevlensize, prevlen = 0;
    // index为负，从尾部开始遍历
    if (index < 0) {
        index = (-index)-1;
        // 获取尾指针
        p = ZIPLIST_ENTRY_TAIL(zl);
        if (p[0] != ZIP_END) {
            // 解码前置节点长度
            ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            while (prevlen > 0 && index--) {
                p -= prevlen;
                // 解码前置节点长度
                ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            }
        }
    } else {
    // index为正，从头部开始遍历
        p = ZIPLIST_ENTRY_HEAD(zl);
        while (p[0] != ZIP_END && index--) {
            // 获取当前节点的整体长度，包括pre_entry_length，encoding，contents三部分
            p += zipRawEntryLength(p);
        }
    }
    return (p[0] == ZIP_END || index > 0) ? NULL : p;
}

而删除节点的逻辑跟插入节点的有些相像，也会产生 连锁更新，删除节点ziplistDelete() 和 删除给定多个节点 ziplistDeleteRange() 核心逻辑函数都是 __ziplistDelete()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/* ziplist.c: line 678 */
unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsigned int num) {
    unsigned int i, totlen, deleted = 0;
    size_t offset;
    int nextdiff = 0;
    zlentry first, tail;
    // 获取p指向的节点信息
    zipEntry(p, &first);
    // 计算num个节点占用的内存
    for (i = 0; p[0] != ZIP_END && i < num; i++) {
        p += zipRawEntryLength(p);
        deleted++;
    }
    totlen = p-first.p; /* Bytes taken by the element(s) to delete. */
    if (totlen > 0) {
        if (p[0] != ZIP_END) {
            // 执行到这里，表示被删除节点后面还存在节点
            // 判断最后一个被删除的节点的后继节点的header中的存放前置节点长度的空间
            // 能不能容纳第一个被删除节点的前置节点的长度
            nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);
            p -= nextdiff;
            zipStorePrevEntryLength(p,first.prevrawlen);
            // 更新尾部相对于头部的便宜
            ZIPLIST_TAIL_OFFSET(zl) =
                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))-totlen);
            // 如果被删除节点后面还存在节点，就需要将nextdiff计算在内
            zipEntry(p, &tail);
            if (p[tail.headersize+tail.len] != ZIP_END) {
                ZIPLIST_TAIL_OFFSET(zl) =
                   intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
            }
            // 将被删除节点后面的内存空间移动到删除的节点之后
            memmove(first.p,p,
                intrev32ifbe(ZIPLIST_BYTES(zl))-(p-zl)-1);
        } else {
            // 执行到这里，表示被删除节点后面没有节点了
            ZIPLIST_TAIL_OFFSET(zl) =
                intrev32ifbe((first.p-zl)-first.prevrawlen);
        }
        // 缩小内存并更新ziplist的长度
        offset = first.p-zl;
        zl = ziplistResize(zl, intrev32ifbe(ZIPLIST_BYTES(zl))-totlen+nextdiff);
        ZIPLIST_INCR_LENGTH(zl,-deleted);
        p = zl+offset;
        // 如果nextdiff不等于0，说明被删除节点后面节点的header信息还需要更改
        if (nextdiff != 0)
            // 连锁更新
            zl = __ziplistCascadeUpdate(zl,p);
    }
    return zl;
}

连锁更新 函数 __ziplistCascadeUpdate()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/* ziplist.c: line 616 */
unsigned char *__ziplistCascadeUpdate(unsigned char *zl, unsigned char *p) {
    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), rawlen, rawlensize;
    size_t offset, noffset, extra;
    unsigned char *np;
    zlentry cur, next;
    while (p[0] != ZIP_END) {
        // 将p所指向节点的信息保存到cur结构体中
        zipEntry(p, &cur);
        // 当前节点的长度
        rawlen = cur.headersize + cur.len;
        // 编码当前节点的长度所需的字节数
        rawlensize = zipStorePrevEntryLength(NULL,rawlen);
        // 如果没有后续节点需要更新了，就退出
        if (p[rawlen] == ZIP_END) break;
        // 去除后续节点的信息保存到next结构体中
        zipEntry(p+rawlen, &next);
        // 当后续节点的空间已经足够了，就直接退出
        if (next.prevrawlen == rawlen) break;
        // 当后续节点的空间不足够，则需要进行扩容操作
        if (next.prevrawlensize < rawlensize) {
            // 记录p的偏移值
            offset = p-zl;
            // 记录需要增加的长度
            extra = rawlensize-next.prevrawlensize;
            // 扩展zl的大小
            zl = ziplistResize(zl,curlen+extra);
            // 获取p相对于新的zl的值
            p = zl+offset;
            // 记录下一个节点的偏移量
            np = p+rawlen;
            noffset = np-zl;
            // 当 next 节点不是表尾节点时，更新列表到表尾节点的偏移量
            if ((zl+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) != np) {
                ZIPLIST_TAIL_OFFSET(zl) =
                    intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);
            }
            // 向后移动cur节点之后的数据，为新的header腾出空间
            memmove(np+rawlensize,
                np+next.prevrawlensize,
                curlen-noffset-next.prevrawlensize-1);
            zipStorePrevEntryLength(np,rawlen);
            // 移动指针，继续处理下一个节点
            p += rawlen;
            curlen += extra;
        } else {
            if (next.prevrawlensize > rawlensize) {
                // 执行到这里，next节点编码前置节点的header空间有5个字节，但是此时只需要一个字节，Redis不提供缩小操作，而是直接将长度强制性写入五个字节中
                zipStorePrevEntryLengthLarge(p+rawlen,rawlen);
            } else {
                // 运行到这里，说明刚好可以存放
                zipStorePrevEntryLength(p+rawlen,rawlen);
            }
            // 退出，代表空间足够，后续空间不需要更改
            break;
        }
    }
    return zl;
}

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-source-ziplist.html
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

wettper <br /><br /> 现 离职状态 程序猿 <br /><br /> 叫醒我的不止阳光，还有梦想！<br /><br /> 喵喵、念念、健身、吉他！