Redis数据结构——链表和字典

2、链表

链表提供了高效的节点重排能力，以及顺序性节点的访问方式，并且可以通过增删节点来灵活的调整链表的长度。

作为一种常用的数据结构，链表内置在很多高级的编程语言里面，因为Redis使用的C语言并没有内置这种数据结构，所以Redis自己构建了自己的链表实现。

链表在Redis中的应用十分广泛，比如列表键的底层实现之一就是链表，当一个列表键包含了数量比较多的元素时，又或者列表中包含的元素都是比较长的字符串时，Redis就会使用链表作为列表键的底层实现，除了列表键的底层是链表外，发布与订阅，慢查询，监视器等功能也用到了链表，Redis服务器本身还使用来保存多个客户端的状态信息，以及使用链表来保存多个客户端的状态信息，以及使用链表来构建客户端输出缓冲区。

2.1链表和链表节点的实现

每个链表节点用一个adlist.h/listNode结构来表示：

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

多个listNode可以通过prev和next指针组成双端链表，如图2-1所示：

虽然仅仅用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 结构为链表提供了head，表尾指针tail，以及链表的长度计数器len，而dup，free，和match成员则是用于实现多态链表所需的类型特定函数：

• dup 函数用于复制链表节点所保存的值；
• free函数用于释放链表节点所保存的值；
• match函数则用于对比链表节点所保存的值和另一个输入值是否相等；

图2-2是由一个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三个属性为节点设置类型特定函数，所以链表可以用于保存各种不同类型的值；

2.2、链表和链表节点的API

下表列出了所有用于操作链表和链表节点的API

函数	作用	时间复杂度
listSetDupMethod	将给定的函数设置为链表的节点值复制函数	O(1)
listGetDupMethod	返回链表当前正在使用的节点值复制函数	复制函数可以通过链表的dup属性获得，O(1)
listSetFreeMethod	将给定的函数设置为链表的节点值释放函数	O(1)
listGetFree	返回链表当前正在使用的节点释放函数	释放函数可以通过链表的free属性直接获得,O(1)
listSetMatchMethod	将给定的函数设置为链表的节点值对比函数	O(1)
listGetMatchMethod	返回链表当前正在使用的节点值对比函数	对比函数可以直接通过链表的match属性直接获得，O(1)
listLength	返回链表的长度（包含了多少个节点）	链表长度可以通过链表的len属性直接获得，O(1)
listFirst	返回链表的表头节点	表头节点可以通过链表的head属性直接获得，O(1)
listLast	返回链表的表尾节点	表尾节点可以通过链表的tail属性直接获取，O(1)
listPrevNode	返回给定节点的前置节点	前置节点可以通过当前节点的prev指针直接获取，O(1)
listNextNode	返回给定节点的后置节点	后置节点可以通过给定节点的next节点直接获取，O(1)
listNodeValue	返回给定节点目前正在保存的值	节点值可以通过给定节点的value属性直接获取，O(1)
listCreate	创建一个不含任何节点的新链表	O(1)
listAddNodeHead	将一个包含给定值的新节点添加到给定链表的表头	O(1)
listAddNodeTail	将一个包含给定值的新节点添加到给定链表的表尾	O(1)
listInsertNode	将一个包含给定值的新节点添加到给定节点的之前或之后	O(1)
listSearchKey	查找并返回链表包含给定值的节点	O(N)，N为链表长度
listIndex	返回链表在给定索引上的节点	O(N)，N为链表长度
listDelNode	从链表中删除给定节点	O(N)，N为链表长度
listRotate	将链表的表尾节点弹出，然后被弹出的节点插入到链表的表头，成为新的表头节点	O(1)
listDup	复制一个给定的链表副本	O(N)，N为链表长度
listRelease	释放给定的链表，以及链表中所有节点	O(N)，N为链表长度

3、字典

字典，又称为符号表，关联数组，或映射，是一种用于保存键值对的抽象数据结构。

在字典中，一个键可以和一个值进行关联（或者说将键映射成值），这些关联的键和值就叫做键值对。

字典中的每个键都是独一无二的，程序可以在字典中根据键查找与之关联的值，或者通过键来更新值，又或者根据键来删除整个键值对，等等。

字典经常作为一种数据结构内置在很多高级语言里面，但Redis所使用的C语言并没有内置这种数据结构，因此Redis构建了自己的字典实现。

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

3.1字典的实现

Redis 的字典使用哈希表作为底层实现，一个哈希表里面可以有多个哈希表节点，而每个哈希表节点就保存了字典中的一个键值对。

接下来将分别介绍Redis的哈希表，哈希表节点以及字典的实现

3.1.1、哈希表

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 数组的那个索引上，图3-1展示了一个大小为4的空哈希表（没有包含任何键值对）。

3.1.2、哈希表节点

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

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

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

next属性是指向另一个哈希表节点的指针，这个指针可以将多个哈希值相同的键值对连接在一起，以此来解决键冲突的问题。

举个栗子：图3-2就展示了如何通过next指针，将两个索引值相同的键k1 和 k2 连接在一起。

3.1.3、字典

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

typedef struct dict {
    //类型特定函数
    dictType *type;
    
    //私有数据
    void *privdata;
    
    //哈希表
    dictht ht[2];
    
    //rehash索引
    //当rehash不再进行时，值为-1
    int 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。

图3-3展示了一个普通状态下（没有rehash）的字典。

3.2、哈希算法

当要将一个新的键值对添加到字典里面时，程序需要先根据键值对的键计算出哈希值和索引值，然后再根据索引值，将包含新键值对的哈希表节点放到哈希表数组的指定索引上。

Redis计算哈希值和索引值的哈希值的方式如下：

使用字典设置的哈希函数，计算出键key的哈希值

hash = dict->type ->hashFunction(key);

使用哈希表的sizemask属性和哈希值，计算出索引，根据情况的不同，ht[x] 可以是ht[0] 或者 ht[1]

index = hash & dict -> ht[x].sizemask;

举个栗子：如果我们要将一个键值对k0和v0添加到一个字典（该字典如图3-4所示）里面，那么程序会先使用语句：

​ hash = dict -> type -> hashFunction(k0);

计算出键k0的哈希值，假设计算得出的哈希值为8，那么程序会继续使用语句：

​ index = hash & ht[0].sizemask = 8 & 3 = 0

计算出k0的索引值为0，这表示包含键值对k0 和 v0 的节点应该被放置到哈希表数组的索引0位置上，如图3-5所示

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

3.3、解决键冲突

当有了两个或两个以上数量的键被分配到哈希表数组的同一索引上面时，我们称这些键发生了冲突

Redis的哈希表采用链地址法来解决键冲突，每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点就可以使用这个单向链表连接起来，这就解决了键冲突问题。

举个栗子：假设程序要将键值对k2 和 v2 t添加到图3-6 所示的哈希表里，并且计算得出k2的索引值为2，那就和键k1发生了冲突，而解决冲突的方法就是链地址法，使用next指针将键k1,k2 连接起来，如图3-7所示。

3.4、rehash

随着操作的不断进行，哈希表保存的键值对会逐渐的增多或者时减少，为了让哈希表的负载因子维持在一个合理的范围之内，当哈希表键值对数量太多或者太少时，程序需要对哈希表的大小进行相应的扩展或者是收缩。

扩展或者收缩哈希表的工作可以通过执行rehash操作来完成，Redis 对字典的哈希表执行的rehash的步骤如下：

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

   • 如果执行的是扩容操作，那么ht[1]的大小为第一个大于等于ht[0].used*2的2^n（2的幂次方）；
   • 如果执行的是收缩操作，那么ht[1]的大小为第一个大于等于ht[0].used*2的2^n;

2. 将保存在ht[0]中的所有键值对rehash到ht[1]上面：rehash指的是重新计算键的哈希值和索引值，然后将键值对放置到ht[1]哈希表的指定位置上面。

3. 当ht[0]包含的所有键值对都迁移到了ht[1]之后（ht[0]变成了空表），释放ht[0]，将ht[1]设置为ht[0]，并在ht[1]新创建一个空的哈希表，为下一次rehash做准备。

3.5、哈希表的扩容与缩容

3.5.1、扩容操作

当以下条件中任何一个被满足时，程序会自动开始对哈希表执行扩容操作

1. 服务器目前没有在执行BGSAVE命令或者BGREWRITEAOF命令，并且哈希表的负载因子大于等于1。
2. 服务器目前正在执行BGSAVE命令或者BGREWRITEAOF命令，并且哈希表的负载因子大于等于5，（其中哈希表的负载因子可以通过公式：负载因子 = 哈希表已保存节点数量 / 哈希表大小）

根据BGSAVE命令或BGREWRITEAOF命令是否正在执行，服务器服务器执行扩展操作所需的负载因子并不相同，这是因为在执行BGSAVE命令或者BGREWRITEAOF命令的过程中，Redis需要创建当前服务器进程的子进程，而大多数操作系统都采用写时复制技术来优化子进程的使用效率，所以在子进程存在期间，服务器会提高扩展操作所需的负载因子，从而尽可能的避免在子进程存在期间进行扩展操作，这可以避免不必要的内存写入操作，最大限度的节约内存。

3.5.2、缩容

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

3.6、渐进式rehash

扩容或者缩容哈希表需要将ht[0]里面的所有键值对rehash到ht[1]里面，但是，这个rehash并不是一次性，集中性完成的，而是分多次、渐进式的完成的。

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

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

以下是哈希表渐进式rehash的详细步骤：

1. 为ht[1]分配空间，让字典同时持有ht[0]和ht[1]两个哈希表
2. 在字典中维持一个索引计数器变量rehashidx，并将它的值设置为0，表示rehash工作正式开始。
3. 在rehash进行期间，每次对字典执行添加、删除、查找或者更新操作时，程序除了执行指定的操作以外还会顺带将ht[0]哈希表在rehashidx索引上的所有键值对rehash到ht[1]，当rehash工作完成之后，程序将rehashidx属性的值增1。
4. 随着字典操作的不断执行，最终在某个时间点上，ht[0]的所有键值对都会被rehash至ht[1]，这时程序将rehashidx的值设置为-1，表示rehash操作已经完成。

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

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

因为在进行渐进式rehash的过程中，字典会同时使用ht[0]和ht[1]两个哈希表，所以在渐进式rehash进行期间，字典的删除，查找，更新，等操作会在两个哈希表上进行，例如，要在字典里面操作一个键的话，程序会先在ht[0]里面进行查找，如果没找到就会继续到ht[1]里面进行查找。

另外，在渐进式rehash执行期间，新添加到字典的键值对一律会保存到ht[1]里面，而ht[0]则不再进行任何添加操作，这一措施保证了ht[0]包含的键值对数量只减不增，并随着rehash操作的执行而最终变成空表。

3.7、字典API

下表列出了字典的主要操作

函数	作用	时间复杂度
dictCreate	创建一个新的字典	O(1)
dictAdd	将给定的键值对添加到地点里面	O(1)
dictReplace	将给定的键值对添加到字典里面，如果键已经存在于字典，那么用新值取代原值	O(1)
dictFetchValue	返回给定键的值	O(1)
dictGetRandomKey	从字典中随机返回一个键值对	O(1)
dictDelete	从字典中删除给定键对应的键值对	O(1)
dictRelese	释放给定的字典，以及字典所包含的所有键值对	O(N)，N为字典所包含的键值对数量

这边文章为看了黄健宏老师所著的《Redis设计与实现》后所做的笔记，若有侵权，请联系删除