【Redis实现系列】双端链表、字典、跳表

双端链表

• 链表在Redis中的应用非常广泛，比如列表键（lpush、rpush）的底层实现之一就是链表。

  • 当一个列表键包含了数量比较多的元素，又或者列表中包含的元素都是比较长的字符串时，Redis就会使用链表作为列表键的底层实现。

• 除了链表键之外，发布与订阅、慢查询、监视器等功能也用到了链表，Redis服务器本身还使用链表来保存多个客户端的状态信息，以及使用链表来构建客户端输出缓冲区（output buffer）

实现

链表节点：adlist.h/listNode（双端链表）

typedef struct listNode {
    // 前置节点
    struct listNode * prev;
    // 后置节点
    struct listNode * next;
    // 节点的值
    void * value;
}listNode;

链表：adlist.h/list

typedef struct list {
    // 表头节点
    listNode * head;
    // 表尾节点
    listNode * tail;
    // 链表所包含的节点数量
    unsigned long len;
    
    /**
      * 下面是实现多态链表所需的类型特定函数，因为 c 没有继承，所以对于不同类型的特定操作就需要提供额外的函数来执行，
      * 所以就不能把不同类型的额外操作写死在增加或者删除或者查找的逻辑里。
      * 
      * 可以总结一下，redis 支持元素多态必须配有三个函数
      *   dup：复制，不同类型元素添加时附加操作可能不同（添加时使用）
      *   match/compare：比较，确定是否连个节点相同（查找时使用）
      *   free：释放，不同类型元素删除时附加操作可能不同（删除时使用）
      */
    
    // 节点值复制函数
    void *(*dup)(void *ptr);
    // 节点值释放函数
    void (*free)(void *ptr);
    // 节点值对比函数
    int (*match)(void *ptr,void *key);
} list;

特性总结

• 双端：链表节点带有prev和next指针，获取某个节点的前置节点和后置节点的复杂度都是O（1）。

• 无环：表头节点的prev指针和表尾节点的next指针都指向NULL，对链表的访问以NULL为终点。

• 带表头指针和表尾指针：通过list结构的head指针和tail指针，程序获取链表的表头节点和表尾节点的复杂度为O（1）。

• 带链表长度计数器：程序使用list结构的len属性来对list持有的链表节点进行计数，程序获取链表中节点数量的复杂度为O（1）。

• 多态：链表节点使用void*指针来保存节点值，并且可以通过list结构的dup、free、match三个属性为节点值设置类型特定函数，所以链表可以用于保存各种不同类型的值。

小结

API：

链表被广泛用于实现Redis的各种功能，比如列表键、发布与订阅、慢查询、监视器等。

实现

• 每个链表节点由一个listNode结构来表示，每个节点都有一个指向前置节点和后置节点的指针，所以Redis的链表实现是双端链表。

• 每个链表使用一个list结构来表示，这个结构带有表头节点指针、表尾节点指针，以及链表长度等信息。

• 因为链表表头节点的前置节点和表尾节点的后置节点都指向NULL，所以Redis的链表实现是无环链表。

• 通过为链表设置不同的类型特定函数，Redis的链表可以用于保存各种不同类型的值。

字典

概述

• 字典在Redis中的应用相当广泛，比如Redis的数据库就是使用字典来作为底层实现的，对数据库的增、删、查、改操作也是构建在对字典的操作之上的。

• 了用来表示数据库之外，字典还是哈希键（hset）的底层实现之一

  • 当一个哈希键包含的键值对比较多，又或者键值对中的元素都是比较长的字符串时，Redis就会使用字典作为哈希键的底层实现。

• 除了用来实现数据库和哈希键之外，Redis的不少功能也用到了字典。

实现

哈希表节点 dictEntry

typedef struct dictEntry {
    // 键
    void *key;
    // 值
    union{
        void *val;
        uint64_tu64;
        int64_ts64;
    } v;
    // 指向下个哈希表节点，形成链表
    struct dictEntry *next;
} dictEntry;

哈希表 dict.h/dictht

typedef struct dictht {
    // 哈希表数组
    dictEntry **table;
    // 哈希表数组大小
    unsigned long size;
    // 哈希表大小掩码，用于计算索引值，总是等于size-1
    unsigned long sizemask;
    // 该哈希表已有节点的数量
    unsigned long used;
} dictht;

字典 dict.h/dict

typedef struct dict {
    // 类型特定函数
    dictType *type;
    // 私有数据
    void *privdata;
    // 哈希表
    dictht ht[2];
    // rehash 索引，当rehash 不在进行时，值为-1
    in trehashidx; /* rehashing not in progress if rehashidx == -1 */
} dict;

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

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

  typedef struct dictType {
      // 计算哈希值的函数
      unsigned int (*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;
  

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

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

哈希算法

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

• 当字典被用作数据库的底层实现，或者哈希键的底层实现时，Redis使用MurmurHash2算法来计算键的哈希值。这种算法的优点在于，即使输入的键是有规律的，算法仍能给出一个很好的随机分布性，并且算法的计算速度也非常快。

使用哈希表的sizemask性和哈希值（根据情况不同，ht[x] 可以是ht[0]，或者ht[1]），计算出索引值 index = hash & dict->ht[x].sizemask;

rehash

为了让哈希表的负载因子（load factor）维持在一个合理的范围之内，当哈希表保存的键值对数量太多或者太少时，程序需要对哈希表的大小进行相应的扩展或者收缩。

当以下条件中的任意一个被满足时，会 rehash：

• 负载因子：load_factor = ht[0].used / ht[0].size

• 扩容

  • 服务器目前没有在执行BGSAVE命令或者BGREWRITEAOF命令，并且哈希表的负载因子大于等于1。
  • 服务器目前正在执行BGSAVE命令或者BGREWRITEAOF命令，并且哈希表的负载因子大于等于5。
    • 因为在执行BGSAVE命令或BGREWRITEAOF命令的过程中，Redis需要创建当前服务器进程的子进程，而大多数操作系统都采用写时复制（copy-on-write）技术来优化子进程的使用效率，所以在子进程存在期间，服务器会提高执行扩展操作所需的负载因子，从而尽可能地避免在子进程存在期间进行哈希表扩展操作，这可以避免不必要的内存写入操作，最大限度地节约内存。

• 缩容

  • 当哈希表的负载因子小于0.1时，程序自动开始对哈希表执行收缩操作。

rehash 步骤

• 为字典的ht[1]哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及ht[0]当前包含的键值对数量（也即是ht[0].used属性的值）：

  • 如果执行的是扩展操作，那么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做准备。

渐进式rehash

rehash动作并不是一次性、集中式地完成的，而是分多次、渐进式地完成的。

原因

• 如果ht[0]里只保存着四个键值对，那么服务器可以在瞬间就将这些键值对全部rehash到ht[1]；但是，如果哈希表里保存的键值对数量不是四个，而是四百万、四千万甚至四亿个键值对，那么要一次性将这些键值对全部rehash到ht[1]的话，庞大的计算量可能会导致服务器在一段时间内停止服务。

• 因此，为了避免rehash对服务器性能造成影响，服务器不是一次性将ht[0]里面的所有键值对全部rehash到ht[1]，而是分多次、渐进式地将ht[0]里面的键值对慢慢地rehash到ht[1]。

• 渐进式rehash的好处在于它采取分而治之的方式，将rehash键值对所需的计算工作均摊到对字典的每个添加、删除、查找和更新操作上，从而避免了集中式rehash而带来的庞大计算量。

渐进式rehash步骤

• 为ht[1]分配空间，让字典同时持有ht[0]和ht[1]两个哈希表。

• 在字典中维持一个索引计数器变量rehashidx，并将它的值设置为0，表示rehash工作正式开始。

• 在rehash进行期间，每次对字典执行添加、删除、查找或者更新操作时，程序除了执行指定的操作以外，还会顺带将ht[0]哈希表在rehashidx索引上的所有键值对rehash到ht[1]，当rehash工作完成之后，程序将rehashidx属性的值增一。

• 随着字典操作的不断执行，最终在某个时间点上，ht[0]的所有键值对都会被rehash至ht[1]，这时程序将rehashidx属性的值设为-1，表示rehash操作已完成。

渐进式rehash执行期间的哈希表操作

• 因为在进行渐进式rehash的过程中，字典会同时使用ht[0]和ht[1]两个哈希表，所以在渐进式rehash进行期间，字典的删除（delete）、查找（find）、更新（update）等操作会在两个哈希表上进行。
  • 例如，要在字典里面查找一个键的话，程序会先在ht[0]里面进行查找，如果没找到的话，就会继续到ht[1]里面进行查找，诸如此类。
• 另外，在渐进式rehash执行期间，新添加到字典的键值对一律会被保存到ht[1]里面，而ht[0]则不再进行任何添加操作，这一措施保证了ht[0]包含的键值对数量会只减不增，并随着rehash操作的执行而最终变成空表。

小结

API：

字典被广泛用于实现Redis的各种功能，其中包括数据库和哈希键。

实现

• Redis中的字典使用哈希表作为底层实现，每个字典带有两个哈希表，一个平时使用，另一个仅在进行rehash时使用。

• 当字典被用作数据库的底层实现，或者哈希键的底层实现时，Redis使用MurmurHash2算法来计算键的哈希值。

• 哈希表使用链地址法来解决键冲突，被分配到同一个索引上的多个键值对会连接成一个单向链表。

• 在对哈希表进行扩展或者收缩操作时，程序需要将现有哈希表包含的所有键值对rehash到新哈希表里面，并且这个rehash过程并不是一次性地完成的，而是渐进式地完成的。

跳跃表

Redis使用跳跃表作为有序集合键（zadd ）的底层实现之一

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

实现

跳跃表节点：redis.h/zskiplistNode

typedef struct zskiplistNode {
    // 层
    struct zskiplistLevel {
        // 前进指针
        struct zskiplistNode *forward;
        // 跨度
        unsigned int span;
    } level[];
    
    // 后退指针
    struct zskiplistNode *backward;
    // 分值
    double score;
    
    /**
     * 可以发现，zskipList 的值对象并不是多态的，没有多态函数来提供
     * 因为 zskipList 只被用作有序集合的一种实现，再无其他用途
     * 但是 list 和 dict 除了用来存储 redisObject，还会用来存储其他内容
     */
    // 成员对象
    robj *obj;
} zskiplistNode;

• 后退指针

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

• 分值和成员

  • 节点的分值（score属性）是一个double类型的浮点数，跳跃表中的所有节点都按分值从小到大来排序。
  • 节点的成员对象（obj属性）是一个指针，它指向一个字符串对象，而字符串对象则保存着一个SDS值。
  • 在同一个跳跃表中，各个节点保存的成员对象必须是唯一的，但是多个节点保存的分值却可以是相同的：分值相同的节点将按照成员对象在字典序中的大小来进行排序，成员对象较小的节点会排在前面（靠近表头的方向），而成员对象较大的节点则会排在后面（靠近表尾的方向）。

• 层数组：

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

  前进指针：

  • 每个层都有一个指向表尾方向的前进指针（level[i].forward属性），用于指向这个节点，在该层指向的下一个节点，如果没有就是 NULL

  跨度：

  • 层的跨度（level[i].span属性）用于记录两个节点之间的距离：两个节点之间的跨度越大，它们相距得就越远。指向NULL的所有前进指针的跨度都为0，因为它们没有连向任何节点。

  • 跨度实际上是用来计算排位（rank）的：在查找某个节点的过程中，将沿途访问过的所有层的跨度累计起来，得到的结果就是目标节点在跳跃表中的排位。

跳跃表：redis.h/zskiplist

typedef struct zskiplist {
    // 表头节点和表尾节点
    // 定位表头节点和表尾节点的复杂度为O（1）。
    structz skiplistNode *header, *tail;
    // 表中节点的数量
    // 在O（1）复杂度内返回跳跃表的长度。
    unsigned long length;
    // 表中层数最大的节点的层数
    int level;
} zskiplist;

示例：

• 查找 o3 元素：

  • 跨度为 1 + 2 = 3

  • 查找过程为： 根据 level 属性找到 head 第 5 层不为 NULL， target >= (head->level[5]->forward->sorce) ，所以会前进到 o3

    

• 查找 o2 元素：

  • 跨度为 1 + 1 = 2

  • 查找过程为：根据 level 属性找到 head 第 5 层不为 NULL，(head->sorce) < target <= (head->level[5]->forward->sorce) ，所以会下降

    到了第四层，target >= (head->level[4]->forward->sorce) ，所以会前进到 o1

    到了第三层，(o1->sorce) < target <= (o1->leavel[3]->forward->sorce)，所以会下降

    到了第二层，target >= (o1->leavel[2]->forward->sorce)，所以会前进到 o2

  

小结

API：

跳跃表是有序集合的底层实现之一。

实现

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