《Redis设计与实现》之字典

最新推荐文章于 2024-04-26 10:40:58 发布

Kevin在成长

最新推荐文章于 2024-04-26 10:40:58 发布

阅读量80

点赞数

文章标签： redis

本文链接：https://blog.csdn.net/weixin_44682222/article/details/111088372

版权

字典：用于保存键值对(key-value pair)的抽象数据结构
在字典中，一个键和一个值进行关联，建立之间的映射关系
字典作为一种数据结构内置于很多高级编程语言中，但是Redis所使用的C语言并没有内置这种数据结构，所以Redis构建了自己的字典实现。

1.字典的实现

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

1.1哈希表

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

1.2哈希表节点

就是上面提到的dictEntry结构，每个dictEntry保存一个键值对

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

key属性保存键值对中的键
v属性保存键值对中的值，值可以是一个指针，或者是uint64_t 整数，又或者是int64_t 整数
next属性指向另外一个哈希表节点的指针，将多个哈希值相同的键值对连接在一起，解决键冲突问题

1.3.字典

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

type属性一个指向dictType结构的指针，每个dictType结构保存的是一簇用于操作特定类型键值对的函数
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属性包含两个项（ht[0],ht[1]）的数组，每一项都是一个dictht哈希表
字典只使用ht[0]哈希表，ht[1]只会在对ht[0]哈希表进行rehash时使用
rehashidx属性记录rehash当前的进度，如果没有在进行rehash，值为-1

2.哈希算法

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

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

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

3.解决键冲突

键冲突：当两个或者以上数量的键被分配到哈希表数组的同一个索引上面

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

4.rehash

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

扩展或者收缩哈希表是执行rehash实现的

具体的步骤如下下：
为字典的ht[1]哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及ht[0]当前包含的键值对数量（也就是ht[0].used属性的值）
为字典的 ht[1] 哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及 ht[0] 当前包含的键值对数量（也即是ht[0].used 属性的值）
如果执行的是扩展操作，那么 ht[1] 的大小为第一个大于等于 ht[0].used * 2 的

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

将保存在 ht[0] 中的所有键值对 rehash 到 ht[1] 上面： rehash 指的是重新计算键的哈希值和索引值，然后将键值对放置到 ht[1] 哈希表的指定位置上。
当 ht[0] 包含的所有键值对都迁移到了 ht[1] 之后（ht[0] 变为空表），释放 ht[0] ，将 ht[1] 设置为 ht[0] ，并在 ht[1] 新创建一个空白哈希表，为下一次 rehash 做准备。

举个例子，假设程序要对字典的 ht[0] 进行扩展操作，那么程序将执行以下步骤：

ht[0].used 当前的值为 4 ， 4 * 2 = 8 ，而 8 （

）恰好是第一个大于等于 4 的 2 的 n 次方，所以程序会将 ht[1] 哈希表的大小设置为 8 。

将 ht[0] 包含的四个键值对都 rehash 到 ht[1]

释放 ht[0] ，并将 ht[1] 设置为 ht[0] ，然后为 ht[1] 分配一个空白哈希表

不难发现，原来的哈希表Ht[0]大小为4，现在成功扩展为8

5.哈希表自动进行扩展和收缩操作

当以下条件中的任意一个被满足时，程序会自动开始对哈希表执行扩展操作：
服务器目前没有在执行 BGSAVE 命令或者 BGREWRITEAOF 命令，并且哈希表的负载因子大于等于 1 ；
服务器目前正在执行 BGSAVE 命令或者 BGREWRITEAOF 命令，并且哈希表的负载因子大于等于 5 ；
其中哈希表的负载因子可以通过公式：

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

计算得出。
比如说，对于一个大小为 4 ，包含 4 个键值对的哈希表来说，这个哈希表的负载因子为：

load_factor = 4 / 4 = 1

又比如说，对于一个大小为 512 ，包含 256 个键值对的哈希表来说，这个哈希表的负载因子为：

load_factor = 256 / 512 = 0.5

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

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