typedef struct zskiplistNode {
    sds ele;
    double score;
    struct zskiplistNode backward;
    struct zskiplistLevel {
        struct zskiplistNode forward;
        unsigned long span;
    } level[];
} zskiplistNode;

typedef struct zskiplist {
    struct zskiplistNode header, tail;
    unsigned long length;
    int level;
} zskiplist;

typedef struct zset {
    dict dict;
    zskiplist zsl;
} zset;

$ redis-cli --raw

127.0.0.1:6379> ZADD NameRanking 1 "D瓜哥"
1

127.0.0.1:6379> ZADD NameRanking 2 "https://www.diguage.com";
1

127.0.0.1:6379> ZADD NameRanking 3 "https://github.com/diguage";
1

127.0.0.1:6379> ZRANGE NameRanking 0 -1 WITHSCORES
D瓜哥
1
https://www.diguage.com
2
https://github.com/diguage
3

127.0.0.1:6379> TYPE NameRanking
zset

127.0.0.1:6379> OBJECT encoding NameRanking
ziplist

127.0.0.1:6379> ZADD NameRanking 4 "1234567890123456789012345678901234567890123456789012345678901234"
1

127.0.0.1:6379> ZRANGE NameRanking 0 -1 WITHSCORES
D瓜哥
1
https://www.diguage.com
2
https://github.com/diguage
3
1234567890123456789012345678901234567890123456789012345678901234
4

127.0.0.1:6379> OBJECT encoding NameRanking
ziplist

127.0.0.1:6379> ZADD NameRanking 5 "12345678901234567890123456789012345678901234567890123456789012345"
1

127.0.0.1:6379> ZRANGE NameRanking 0 -1 WITHSCORES
D瓜哥
1
https://www.diguage.com
2
https://github.com/diguage
3
1234567890123456789012345678901234567890123456789012345678901234
4
12345678901234567890123456789012345678901234567890123456789012345
5

127.0.0.1:6379> OBJECT encoding NameRanking
skiplist

127.0.0.1:6379> TYPE NameRanking
zset

typedef struct dictEntry { // (1)
    void key;
    union {
        void val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry next;
} dictEntry;

typedef struct dictType {
    uint64_t (hashFunction)(const void key);
    void (keyDup)(void privdata, const void key);
    void (valDup)(void privdata, const void obj);
    int (keyCompare)(void privdata, const void key1, const void key2);
    void (keyDestructor)(void privdata, void key);
    void (valDestructor)(void privdata, void obj);
} dictType;

/ This is our hash table structure. Every dictionary has two of this as we
 * implement incremental rehashing, for the old to the new table. /
typedef struct dictht {
    dictEntry *table; // (2)
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} dictht;

typedef struct dict {
    dictType type;
    void privdata;
    dictht ht[2]; // (3)
    long rehashidx; /* rehashing not in progress if rehashidx == -1 /
    unsigned long iterators; / number of iterators currently running */
} dict;

1. 计算新的数组长度

   1. 如果是扩容，则 used * 2；

   2. 如果是缩容，则是第一个大于等于 used 的 2n。 — 这点和 Java 不同，HashMap 中没有自动缩容的机制。

2. 将 ht[0] 中的所有键值对重新 Rehash，重新计算哈希值和索引值，放置到 ht[1] 上；

3. 迁移完成后，将 ht[1] 设置为 ht[0]，为 ht[1] 创建一个空白哈希表。

还有几点需要特别注意：

1. 根据是否正在执行 BGSAVE 或 BGREADWRITEAOF 命令，使用不同的负载阈值来决定是否开启对哈希表的自动扩展工作；

2. 当哈希表负载因子小于 0.1 时，会自动开始对哈希表缩容；

3. Rehash 过程是渐进式的：

   1. 开始 Rehash 后，每次对自动进行的添加、删除、查找或更新时，程序会自动将对应的键值对从 ht[0] Rehash 到 ht[1] 上；rehashidx 属性值增一。

   2. 记得有后台定时任务来自动扩展的，怎么没有看到说明文档？

Redis 在哈希对象上的编码有可能是：

1. ziplist

2. hashtable

转换条件是：

1. 哈希对象保存的所有键值对象字符串长度都小于 64 个字节；（通过参数 hash-max-ziplist-value 来调节，默认为 64）

2. 哈希对象保存的键值对数量小于 512 个；（通过参数 hash-max-ziplist-entries 来调节，默认为 512）

1. 这是 64 个字符。

2. 这是 65 个字符。

通过 t_hash.c/hashTypeConvertZiplist 方法来转换。

int 编码的数字范围是： -263 ~ 263 - 1，超出这个范围就会变成 embstr。

embstr 和 raw 都是由SDS动态字符串构成的。唯一区别是：raw 是分配内存的时候，redisobject 和 sds 各分配一块内存，而 embstr 是 redisobject 和 raw 在一块儿内存中。两者的界限在 object.c/OBJ_ENCODING_EMBSTR_SIZE_LIMIT 常量中定义，不能通过参数调节。

Redis 的散列（hashes）的底层存储可以使用 ziplist 和 hashtable。当散列（hashes）可以同时满足以下两个条件时，散列（hashes）使用 ziplist 编码。

1. 散列（hashes）保存的所有键值对的键和值的字符串长度都小于 64 字节。（通过参数 hash-max-ziplist-value 来调节，默认是 64）

2. 散列（hashes）保存的键值对数量小于 512 个。（通过参数 hash-max-ziplist-entries 来调节，默认是 512）

使用 ziplist 编码，每个 key/value 存储结果中 key 用一个 zipEntry 存储，value 用一个 zipEntry 存储。

1. 这是 64 个字符。

2. 这是 65 个字符。

列表（lists）底层是用 quicklist。

查看 Redis 的 t_list.c 文件的提交记录可以看出，从 2014 年 Redis 实现了 quicklist 之后，就把 列表（lists）的实现全部改成 quicklist 来实现了。网上很多很多资料显示列表（lists）有两种不同的编码方案，那都已经过时了。

Redis 的集合（sets）的底层存储可以使用 intset 和 hashtable。当集合（sets）可以同时满足以下两个条件时，集合（sets）使用 intset 编码。

1. 集合（sets）保存的所有值都是整数，而且数字范围在 -264 ~ 264-1 之间。

2. 集合（sets）保存的键数量小于 512 个，（通过 set-max-intset-entries 参数调节，默认是 512）。

1. 当数据较少时，sorted set是由一个 ziplist 来实现的。其中集合元素按照分值从小到大排序。

2. 当数据多的时候，sorted set 是由一个叫 zset 的数据结构来实现的，这个 zset 包含一个 dict + 一个 skiplist。dict 用来查询数据到分数(score)的对应关系，而 skiplist 用来根据分数查询数据（可能是范围查找）。查看编码显示的是 skiplist。

转换的条件是：

1. 有序集合保存的元素数量小于 128 个；（通过参数 zset-max-ziplist-entries 来调节，默认为 128。）

2. 有序集合保存的所有元素成员的长度都要小于 64 个字节；（通过参数 zset-max-ziplist-value 来调节，默认为 64。）

写这个总结，内容不多，但是却花了好长时间，原因如下：

1. 随着 Redis 的演进，网上的文章很多很多过时，比如现在已经不用 linkedlist，而改用 quicklist 了；

2. 网上的资料有错的（注意：D瓜哥的文章也可能会有错，如有发现欢迎留言指正）。

3. D瓜哥对C语言不熟，本地调试环境没有搞好，只能翻代码生看，看代码效率就比较低；

D瓜哥尽量查资料、看代码来确保这些资料的正确性了。不尽之处，还请不吝指正。另外，还有些地点值得动笔，比如网络模型；比如缓存删除算法的更新，后续有机会再写吧。