Redis的设计与实现(3)-字典

Redis 的数据库使用字典实现, 对数据库的增, 删, 查, 改也是构建在对字典的操作之上的.

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

1. 哈希表

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

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 数组的哪个索引上面.

2. 哈希表节点

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

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

• key 键
• v 值
• next 指向下一个哈希表节点指针

1. 值可以是一个 指针, uint64_t 整数, int64_t 整数;
2. next 可以将多个哈希值相同的键值对连接在一次, 以此解决键冲突的问题.

3.字典

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

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

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

1. type 属性是一个指向 dictType 结构的指针, 每个 dictType 结构保存了一簇用于操作特定类型键值对的函数, Redis 会为用途不同的字典设置不同的类型特定函数;
2. 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.

4. 哈希算法

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

面.

Redis 计算哈希值和索引值的方法如下:

# 使用字典设置的哈希函数，计算键 key 的哈希值
hash = dict->type->hashFunction(key);
# 使用哈希表的 sizemask 属性和哈希值，计算出索引值
# 根据情况不同， ht[x] 可以是 ht[0] 或者 ht[1]
index = hash & dict->ht[x].sizemask;

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

MurmurHash 算法目前的最新版本为 MurmurHash3 , 而 Redis 使用的是 MurmurHash2, 关于 MurmurHash 算法的更多信息可以参考该算法的主页: http://code.google.com/p/smhasher/.

该算法已经迁移到 GitHub: https://github.com/aappleby/smhasher

然而, 我在 GitHub 上搜索 Redis 的相关源码, 发现版本不同, 使用的哈希算法也是不相同的:

最新版本的 Redis (5.0已发布), 采用的是 SipHash 哈希算法, 链接:

https://github.com/antirez/redis/blob/unstable/src/dict.c#L84

往回看, 5.0, 4.0 都是 SipHash 哈希算法:

https://github.com/antirez/redis/blob/5.0/src/dict.c#L84

https://github.com/antirez/redis/blob/4.0/src/dict.c#L84

3.2, 3.0, 2.8, 2.6 都是 MurmurHash2 哈希算法:

https://github.com/antirez/redis/blob/3.2/src/dict.c#L92

https://github.com/antirez/redis/blob/3.0/src/dict.c#L92

https://github.com/antirez/redis/blob/2.8/src/dict.c#L92

https://github.com/antirez/redis/blob/2.6/src/dict.c#L98

而更旧的 2.4 2.2, 作者没有说是什么算法, 但是让我回想到 鸟哥 的一篇文章, 讲的是 PHP 的哈希算法, 看样子很像, 估计是 DJBX33A (Daniel J. Bernstein, Times 33 with Addition) 算法.

PHP中的Hash算法

https://github.com/antirez/redis/blob/2.4/src/dict.c#L88

https://github.com/antirez/redis/blob/2.2/src/dict.c#L88

关于哈希算法的, 还找到了两篇文章:

漫谈非加密哈希算法

我为什么要使用哈希

5. 解决键冲突

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

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

因为 dictEntry 节点组成的链表没有指向链表表尾的指针, 为了速度考虑, 程序总是将新节点添加到链表的表头位置, 排在已有节点前面, 操作的复杂度为 O(1).

6. rehash

当哈希表保存的键值对数量太多或者太少时, 程序需要对哈希表的大小进行相应的扩展或者收缩.

扩展和收缩哈希表的工作可以通过执行 rehash (重新散列) 操作来完成, Redis 对字典的哈希表执行 rehash 的步骤如下:

1. 为字典的 ht1 哈希表分配空间, 这个哈希表的空间大小取决于要执行的操作, 以及 ht0 当前包含的键值对数量 (也即是 ht0.used 属性的值):
   • 如果执行的是扩展操作, 那么 ht1 的大小为第一个大于等于 ht0.used * 2 的 2^n (2 的 n 次方幂);
   • 如果执行的是收缩操作, 那么 ht1 的大小为第一个大于等于 ht0.used 的 2^n .
2. 将保存在 ht0 中的所有键值对 rehash 到 ht1 上面: rehash 指的是重新计算键的哈希值和索引值, 然后将键值对放置到 ht1 哈希表的指定位置上.
3. 当 ht0 包含的所有键值对都迁移到了 ht1 之后 (ht0 变为空表), 释放 ht0 , 将 ht1 设置为 ht0 , 并在 ht1 新创建一个空白哈希表, 为下一次 rehash 做准备.

7. 哈希表的扩展与收缩

当以下条件中的任意一个被满足时, 程序会自动开始对哈希表执行扩展操作:

1. 服务器目前没有在执行 BGSAVE 命令或者 BGREWRITEAOF 命令, 并且哈希表的负载因子大于等于 1;
2. 服务器目前正在执行 BGSAVE 命令或者 BGREWRITEAOF 命令, 并且哈希表的负载因子大于等于 5. (感觉书错了, 应该是 0.5 ...)

其中哈希表的负载因子可以通过公式计算得出:

# 负载因子 = 哈希表已保存节点数量 / 哈希表大小
load_factor = ht[0].used / ht[0].size

根据 BGSAVE 命令或 BGREWRITEAOF 命令是否正在执行, 服务器执行扩展操作所需的负载因子并不相同, 这是因为在执行 BGSAVE 命令或 BGREWRITEAOF 命令的过程中, Redis 需要创建当前服务器进程的子进程, 而大多数操作系统都采用写时复制 (copy-on-write) 技术来优化子进程的使用效率, 所以在子进程存在期间, 服务器会提高执行扩展操作所需的负载

因子, 从而尽可能地避免在子进程存在期间进行哈希表扩展操作, 这可以避免不必要的内存写入操作, 最大限度地节约内存.

另一方面, 当哈希表的负载因子小于 0.1 时, 程序自动开始对哈希表执行收缩操作.

8. 渐进式 rehash

为避免 rehash 对服务器性能造成影响, 服务器不是一次性将 ht0 里面的所有键值对全部 rehash 到 ht1 , 而是分多次, 渐进式地将 ht0 里面的键值对慢慢地 rehash 到 ht1.

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

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

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

9. 字典 API

10. 总结

• 字典被广泛用于实现 Redis 的各种功能, 其中包括数据库和哈希键;
• Redis 中的字典使用哈希表作为底层实现, 每个字典带有两个哈希表, 一个用于平时使用, 另一个仅在进行 rehash 时使用. 当字典被用作数据库的底层实现, 或者哈希键的底层实现时, Redis 使用 MurmurHash2 算法来计算键的哈希值;
• 哈希表使用链地址法来解决键冲突, 被分配到同一个索引上的多个键值对会连接成一个单向链表;
• 在对哈希表进行扩展或者收缩操作时, 程序需要将现有哈希表包含的所有键值对 rehash 到新哈希表里面, 并且这个 rehash 过程并不是一次性地完成的, 而是渐进式地完成的.