最全redis源码阅读—ziplist(压缩表)_intrev32ifbe，最新Golang高级面试题汇总

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

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

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

大小端的介绍

ziplist entry的组成

entry组成结构体

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;

void zipEntry(unsigned char \*p, zlentry \*e) {
    // 前一节点长度信息解析
    ZIP\_DECODE\_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
    // 当前节点数据长度与编码信息解析
    ZIP\_DECODE\_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
    e->headersize = e->prevrawlensize + e->lensize;
    e->p = p;
}

前一节点长度信息
前文已经介绍过原理，这里就不再赘述

#define ZIP\_BIG\_PREVLEN 254 
#define ZIP\_DECODE\_PREVLENSIZE(ptr, prevlensize) do { \
 if ((ptr)[0] < ZIP\_BIG\_PREVLEN) { \
 (prevlensize) = 1; \
 } else { \
 (prevlensize) = 5; \
 } \
} while(0);

#define ZIP\_DECODE\_PREVLEN(ptr, prevlensize, prevlen) do { \
 ZIP\_DECODE\_PREVLENSIZE(ptr, prevlensize); \
 if ((prevlensize) == 1) { \
 (prevlen) = (ptr)[0]; \
 } else if ((prevlensize) == 5) { \
 assert(sizeof((prevlen)) == 4); \
 memcpy(&(prevlen), ((char\*)(ptr)) + 1, 4); \
 memrev32ifbe(&prevlen); \
 } \
} while(0);

当前节点数据长度与编码信息

/\* Different encoding/length possibilities \*/
#define ZIP\_STR\_MASK 0xc0 /\* 11000000 \*/
#define ZIP\_STR\_06B (0 << 6) /\* 00000000 \*/
#define ZIP\_STR\_14B (1 << 6) /\* 01000000 \*/
#define ZIP\_STR\_32B (2 << 6) /\* 10000000 \*/
#define ZIP\_INT\_16B (0xc0 | 0<<4) /\* 11000000 \*/
#define ZIP\_INT\_32B (0xc0 | 1<<4) /\* 11010000 \*/
#define ZIP\_INT\_64B (0xc0 | 2<<4) /\* 11100000 \*/
#define ZIP\_INT\_24B (0xc0 | 3<<4) /\* 11110000 \*/
#define ZIP\_INT\_8B 0xfe /\* 11111110 \*/

/\* 4 bit integer immediate encoding |1111xxxx| with xxxx between
 \* 0001 and 1101. \*/
#define ZIP\_INT\_IMM\_MASK 0x0f /\* 00001111 \*/
#define ZIP\_INT\_IMM\_MIN 0xf1 /\* 11110001 \*/
#define ZIP\_INT\_IMM\_MAX 0xfd /\* 11111101 \*/

#define ZIP\_ENTRY\_ENCODING(ptr, encoding) do { \
 (encoding) = (ptr[0]); \
 if ((encoding) < ZIP\_STR\_MASK) (encoding) &= ZIP\_STR\_MASK; \
} while(0)

#define ZIP\_DECODE\_LENGTH(ptr, encoding, lensize, len) do { \
 ZIP\_ENTRY\_ENCODING((ptr), (encoding)); \
 if ((encoding) < ZIP\_STR\_MASK) { \
 if ((encoding) == ZIP\_STR\_06B) { \
 (lensize) = 1; \
 (len) = (ptr)[0] & 0x3f; \
 } else if ((encoding) == ZIP\_STR\_14B) { \
 (lensize) = 2; \
 (len) = (((ptr)[0] & 0x3f) << 8) | (ptr)[1]; \
 } else if ((encoding) == ZIP\_STR\_32B) { \
 (lensize) = 5; \
 (len) = ((ptr)[1] << 24) | \
 ((ptr)[2] << 16) | \
 ((ptr)[3] << 8) | \
 ((ptr)[4]); \
 } else { \
 panic("Invalid string encoding 0x%02X", (encoding)); \
 } \
 } else { \
 (lensize) = 1; \
 (len) = zipIntSize(encoding); \
 } \
} while(0);

unsigned int zipIntSize(unsigned char encoding) {
    switch(encoding) {
    case ZIP_INT_8B:  return 1;
    case ZIP_INT_16B: return 2;
    case ZIP_INT_24B: return 3;
    case ZIP_INT_32B: return 4;
    case ZIP_INT_64B: return 8;
    }
    if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX)
        return 0; /\* 4 bit immediate \*/
    panic("Invalid integer encoding 0x%02X", encoding);
    return 0;
}

int zipTryEncoding(unsigned char \*entry, unsigned int entrylen, long long \*v, unsigned char \*encoding) {
    long long value;
    if (entrylen >= 32 || entrylen == 0) return 0;
    if (string2ll((char\*)entry,entrylen,&value)) {
        if (value >= 0 && value <= 12) {
            \*encoding = ZIP_INT_IMM_MIN+value;
        // ...
        return 1;
    }
    return 0;
}

更新

#define ZIPLIST\_HEAD 0
#define ZIPLIST\_TAIL 1
#define ZIPLIST\_HEADER\_SIZE (sizeof(uint32\_t)\*2+sizeof(uint16\_t))
#define ZIPLIST\_ENTRY\_HEAD(zl) ((zl)+ZIPLIST\_HEADER\_SIZE)
#define ZIPLIST\_ENTRY\_END(zl) ((zl)+intrev32ifbe(ZIPLIST\_BYTES(zl))-1)
unsigned char \*ziplistPush(unsigned char \*zl, unsigned char \*s, unsigned int slen, int where) {
    unsigned char \*p;
    // 头部或尾部插入节点
    p = (where == ZIPLIST_HEAD) ? ZIPLIST\_ENTRY\_HEAD(zl) : ZIPLIST\_ENTRY\_END(zl);
    return \_\_ziplistInsert(zl,p,s,slen);
}

unsigned char \*ziplistInsert(unsigned char \*zl, unsigned char \*p, unsigned char \*s, unsigned int slen) {
    /// 插入节点至p指针指向元素前方
    return \_\_ziplistInsert(zl,p,s,slen);
}

unsigned char \*\_\_ziplistInsert(unsigned char \*zl, unsigned char \*p, unsigned char \*s, unsigned int slen) {
	// 记录当前 ziplist 的长度
    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; 

    /\* Find out prevlen for the entry that is inserted. \*/
    if (p[0] != ZIP_END) {
        // 插入位置不在尾部 
        /\*
 如果 p[0] 不指向列表末端，说明列表非空，并且 p 正指向列表的其中一个节点
 那么取出 p 所指向节点的信息，并将它保存到 entry 结构中
 然后用 prevlen 变量记录前置节点的长度（当插入新节点之后 p 所指向的节点就成了新节点的前置节点）
 \*/
        ZIP\_DECODE\_PREVLEN(p, prevlensize, prevlen);
    } else {
        // 插入位置在尾部
        /\*
 如果 p 指向表尾末端，那么程序需要检查列表是否为：
 1)如果 ptail 也指向 ZIP\_END ，那么列表为空；
 2)如果列表不为空，那么 ptail 将指向列表的最后一个节点。
 \*/
        unsigned char \*ptail = ZIPLIST\_ENTRY\_TAIL(zl);
        // 尾节点存在取长度，不存在长度为0(列表为空时不存在)
        if (ptail[0] != ZIP_END) {
        	// 表尾节点为新节点的前置节点 取出表尾节点的长度
            prevlen = zipRawEntryLength(ptail);
        }
    }
    // s指针指向新增节点数据 slen为数据长度
    // 确定数据编码。数据长度，为整数时返回对应固定长度，为字符串使用slen
    if (zipTryEncoding(s,slen,&value,&encoding)) {
        reqlen = zipIntSize(encoding);
    } else {
        reqlen = slen;
    }
    // 加上前一节点长度信息的长度
    reqlen += zipStorePrevEntryLength(NULL,prevlen);
    // 加上编码与长度信息的长度
    // 此时reqlen为新加入节点的整体长度
    reqlen += zipStoreEntryEncoding(NULL,encoding,slen);

    int forcelarge = 0;
    // 
    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
    // 修复bug,详细分析见:https://segmentfault.com/a/1190000018878466?utm\_source=tag-newest
    if (nextdiff == -4 && reqlen < 4) {
        nextdiff = 0;
        forcelarge = 1;
    }

    offset = p-zl;
    // 调整内存大小
    zl = ziplistResize(zl,curlen+reqlen+nextdiff);
    p = zl+offset;

    // 非空列表插入
    if (p[0] != ZIP_END) {
        // 将p节点后移(没有移动p节点前一节点长度信息)，留出当前节点位置
        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);

        // 写入p节点前一节点长度信息(要插入节点的长度)
        if (forcelarge)
            zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
        else
            zipStorePrevEntryLength(p+reqlen,reqlen);

        // 更新尾节点偏移量
        ZIPLIST\_TAIL\_OFFSET(zl) =
            intrev32ifbe(intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))+reqlen);
        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);
    }

    // 连锁更新
    if (nextdiff != 0) {
        offset = p-zl;
        zl = \_\_ziplistCascadeUpdate(zl,p+reqlen);
        p = zl+offset;
    }

    // 写入前一节点长度信息
    p += zipStorePrevEntryLength(p,prevlen);
    // 写入节点编码与长度信息
    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;
}

__ziplistInsert的步骤如下：
1.求新节点需要的编码长度，以及当前p所指节点的previous_entry_length能否装的下新节点长度，若装不下，则p所指节点头部需要扩展，要多分配内存
2. 重分配内存
3. 移动节点，中间预留出容纳新节点的空间
4.更新之前p所指节点（即插入节点的后续节点）的头部
5. 头部扩展后可能会导致连锁更新
6. 最后写入节点，更新节点数量

连锁更新

插入新节点后若新节点比较长，previous_entry_length需要5字节编码，而新节点后的节点X原来是1字节编码的，头部会扩展为5字节，整个X节点的长度恰好变大为需要5字节编码，而X的后续节点Y之前编码X的长度只需要1字节，装不下又会导致Y的头部扩展………往复下去

因为前置节点长度大于等于254，previous_entry_length才会采用5字节编码，所以当有连续的250-253字节长度的节点时才会导致连锁更新，概率不会很大，并不会因为连锁更新导致非常频繁的分配拷贝释放内存

插入也会导致连锁缩减，但是我们忽略这种情况。因为缩减并不是必须的，并且一个节点也只多占用了4字节内存。没有必要为了缩减几字节的内存而进行内存重分配

static 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 结构中 
        cur = zipEntry(p);
        // 当前节点的长度
        rawlen = cur.headersize + cur.len;
        rawlensize = zipPrevEncodeLength(NULL,rawlen);

        // 如果已经没有后续空间需要更新了，跳出
        if (p[rawlen] == ZIP_END) break;

        // 取出后续节点的信息，保存到 next 结构中
        next = zipEntry(p+rawlen);

        // 后续节点编码当前节点的空间已经足够，无须再进行任何处理，跳出
        // 可以证明，只要遇到一个空间足够的节点，
        // 那么这个节点之后的所有节点的空间都是足够的
        if (next.prevrawlen == rawlen) break;

        if (next.prevrawlensize < rawlensize) {

            // 执行到这里，表示 next 空间的大小不足以编码 cur 的长度
            // 所以程序需要对 next 节点的（header 部分）空间进行扩展

            // 记录 p 的偏移量
            offset = p-zl;
            // 计算需要增加的节点数量
            extra = rawlensize-next.prevrawlensize;
            // 扩展 zl 的大小
            zl = ziplistResize(zl,curlen+extra);
            // 还原指针 p
            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 节点之后的数据，为 cur 的新 header 腾出空间
            memmove(np+rawlensize,
                np+next.prevrawlensize,
                curlen-noffset-next.prevrawlensize-1);
            // 将新的前一节点长度值编码进新的 next 节点的 header
            zipPrevEncodeLength(np,rawlen);

            // 移动指针，继续处理下个节点
            p += rawlen;
            curlen += extra;
        } else {
            if (next.prevrawlensize > rawlensize) {
                // 执行到这里，说明 next 节点编码前置节点的 header 空间有 5 字节
                // 而编码 rawlen 只需要 1 字节
                // 但是程序不会对 next 进行缩小，
                // 所以这里只将 rawlen 写入 5 字节的 header 中就算了。
                zipPrevEncodeLengthForceLarge(p+rawlen,rawlen);
            } else {
                // 运行到这里，
                // 说明 cur 节点的长度正好可以编码到 next 节点的 header 中
                zipPrevEncodeLength(p+rawlen,rawlen);
            }
            // 到这里此节点previous\_entry\_length长度不需要扩展
            // 连锁更新结束
            break;
        }
    }

    return zl;
}

获取节点索引

// 根据索引返回节点
unsigned char \*ziplistIndex(unsigned char \*zl, int index) {
    unsigned char \*p;
    zlentry entry;
    // 处理负数索引
    if (index < 0) {
        // 将索引转换为正数
        index = (-index)-1;      
        // 定位到表尾节点
        p = ZIPLIST\_ENTRY\_TAIL(zl);
        // 如果列表不为空，那么。。。
        if (p[0] != ZIP_END) {
            // 从表尾向表头遍历
            entry = zipEntry(p);
            while (entry.prevrawlen > 0 && index--) {
                // 前移指针
                p -= entry.prevrawlen;
                entry = zipEntry(p);
            }
        }
    // 处理正数索引
    } else {
        // 定位到表头节点
        p = ZIPLIST\_ENTRY\_HEAD(zl);
        while (p[0] != ZIP_END && index--) {
            // 后移指针
            p += zipRawEntryLength(p);
        }
    }

    // 返回结果
    return (p[0] == ZIP_END || index > 0) ? NULL : p;
}

查找

unsigned char \*ziplistFind(unsigned char \*p, unsigned char \*vstr, unsigned int vlen, unsigned int skip) {
    int skipcnt = 0;
    unsigned char vencoding = 0;
    long long vll = 0;
    // 遍历压缩列表 skip为查找前跳过skip个节点
    while (p[0] != ZIP_END) {
        unsigned int prevlensize, encoding, lensize, len;
        unsigned char \*q;

        ZIP\_DECODE\_PREVLENSIZE(p, prevlensize);
        ZIP\_DECODE\_LENGTH(p + prevlensize, encoding, lensize, len);
        q = p + prevlensize + lensize;

        if (skipcnt == 0) {
            /\* Compare current entry with specified entry \*/
            if (ZIP\_IS\_STR(encoding)) {
                // 数据为字符串，判断字符串相等复杂度为O(n)
                if (len == vlen && memcmp(q, vstr, vlen) == 0) {
                    return p;
                }
            } else {
                if (vencoding == 0) {
                    // 首次比对时，对传入值进行解码
                    if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) {
                        /\* If the entry can't be encoded we set it to
 \* UCHAR\_MAX so that we don't retry again the next
 \* time. \*/
                        vencoding = UCHAR_MAX;
                    }
                    /\* Must be non-zero by now \*/
                    assert(vencoding);
                }

                /\* Compare current entry with specified entry, do it only
 \* if vencoding != UCHAR\_MAX because if there is no encoding
 \* possible for the field it can't be a valid integer. \*/
                if (vencoding != UCHAR_MAX) {
                    long long ll = zipLoadInteger(q, encoding);
                    if (ll == vll) {
                        return p;
                    }
                }
            }

            /\* Reset skip count \*/
            skipcnt = skip;
        } else {
            /\* Skip entry \*/
            skipcnt--;
        }

        /\* Move to next entry \*/
        p = q + len;
    }

    return NULL;
}

因为节点中存在字符串，且字符串相等比对的复杂度为O(n), 所以压缩列表查找节点的复杂度为O(n^2)。

删除

unsigned char \*ziplistDelete(unsigned char \*zl, unsigned char \*\*p) {

    // 因为 \_\_ziplistDelete 时会对 zl 进行内存重分配
    // 而内存充分配可能会改变 zl 的内存地址
    // 所以这里需要记录到达 \*p 的偏移量
    size_t offset = \*p-zl;
    zl = \_\_ziplistDelete(zl,\*p,1);

    \*p = zl+offset;

    return zl;
}

static 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;


![img](https://img-blog.csdnimg.cn/img_convert/42fb5b8860584842be167fc6c05bf390.png)
![img](https://img-blog.csdnimg.cn/img_convert/235129bea21e5d6fa92f30f7f0402e34.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

static 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;

[外链图片转存中…(img-quniB0Qw-1715559810123)]
[外链图片转存中…(img-cdODceVA-1715559810124)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！