当前位置：首页 > news >正文

原理Redis-Dict字典

news 2025/8/25 18:47:52

Dict

1) Dict组成
2) Dict的扩容
3) Dict的收缩
4) Dict的rehash
5) 总结

1) Dict组成

Redis是一个键值型（Key-Value Pair）的数据库，可以根据键实现快速的增删改查。而键与值的映射关系正是通过Dict来实现的。

Dict由三部分组成，分别是：哈希表（DictHashTable）、哈希节点（DictEntry）、字典（Dict）

typedef struct dictht {// entry数组// 数组中保存的是指向entry的指针dictEntry **table; // 哈希表大小 (必须是2的n次方)unsigned long size;     // 哈希表大小的掩码，总等于size - 1unsigned long sizemask;     // entry个数unsigned long used; 
} dictht;

typedef struct dictEntry {void *key; // 键union {void *val;uint64_t u64;int64_t s64;double d;} v; // 值// 下一个Entry的指针struct dictEntry *next; 
} dictEntry;

当我们向Dict添加键值对时，Redis首先根据key计算出hash值（h），然后利用 h & sizemask (与运算) 来计算元素应该存储到数组中的哪个索引位置。

假设创建一个哈希表，并初始化它的dictEntry数组为4

在这里插入图片描述

然后存储k1=v1，假设k1的哈希值h =1，则 1&3 =1，因此k1=v1要存储到数组角标1位置。

在内存中创建 dictEmtry，数组指向具体dictEmtry
并将used更新为1

在这里插入图片描述

假设现在有一个新的dictEntry k2=v2，且k2的哈希值与k1一致

将数组的指针指向新的k2 dictEntry (就是将新的dictEntry放在链表的队首)
将旧的k1 dictEntry的地址存储到k2的next指针中
并将used更新为2

在这里插入图片描述

字典Dict

typedef struct dict {dictType *type; // dict类型，内置不同的hash函数void *privdata;     // 私有数据，在做特殊hash运算时用dictht ht[2]; // 一个Dict包含两个哈希表，其中一个是当前数据，另一个一般是空，rehash时使用long rehashidx;   // rehash的进度，-1表示未进行, 0表示正在进行rehashint16_t pauserehash; // rehash是否暂停，1则暂停，0则继续
} dict;

在这里插入图片描述

2) Dict的扩容

Dict中的HashTable就是数组结合单向链表的实现，当集合中元素较多时，必然导致哈希冲突增多，链表过长，则查询效率会大大降低。

Dict在每次新增键值对时都会检查负载因子（LoadFactor = used/size），满足以下两种情况时会触发哈希表扩容：

哈希表的 LoadFactor >= 1，并且服务器没有执行 BGSAVE 或者 BGREWRITEAOF 等后台进程
哈希表的 LoadFactor > 5

static int _dictExpandIfNeeded(dict *d){// 如果正在rehash，则返回okif (dictIsRehashing(d)) return DICT_OK;// 如果哈希表为空，则初始化哈希表为默认大小：4if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);// 当负载因子（used/size）达到1以上，并且当前没有进行bgrewrite等子进程操作// 或者负载因子超过5，则进行 dictExpand ，也就是扩容if (d->ht[0].used >= d->ht[0].size &&(dict_can_resize || d->ht[0].used/d->ht[0].size > dict_force_resize_ratio){// 扩容大小为used + 1，底层会对扩容大小做判断，实际上找的是第一个大于等于 used+1 的 2^nreturn dictExpand(d, d->ht[0].used + 1);}return DICT_OK;
}

3) Dict的收缩

Dict除了扩容以外，每次删除元素时，也会对负载因子做检查，当LoadFactor < 0.1 时，会做哈希表收缩：

// t_hash.c # hashTypeDeleted() 
...
if (dictDelete((dict*)o->ptr, field) == C_OK) {deleted = 1;// 删除成功后，检查是否需要重置Dict大小，如果需要则调用dictResize重置/* Always check if the dictionary needs a resize after a delete. */if (htNeedsResize(o->ptr)) dictResize(o->ptr);
}
...

// server.c 文件
int htNeedsResize(dict *dict) {long long size, used;// 哈希表大小size = dictSlots(dict);// entry数量used = dictSize(dict);// size > 4（哈希表初识大小）并且 负载因子低于0.1return (size > DICT_HT_INITIAL_SIZE && (used*100/size < HASHTABLE_MIN_FILL));
}

int dictResize(dict *d){unsigned long minimal;// 如果正在做bgsave或bgrewriteof或rehash，则返回错误if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;// 获取used，也就是entry个数minimal = d->ht[0].used;// 如果used小于4，则重置为4if (minimal < DICT_HT_INITIAL_SIZE)minimal = DICT_HT_INITIAL_SIZE;// 重置大小为minimal，其实是第一个大于等于minimal的2^nreturn dictExpand(d, minimal);
}

4) Dict的rehash

不管是扩容还是收缩，必定会创建新的哈希表，导致哈希表的size和sizemask变化，而key的查询与sizemask有关。因此必须对哈希表中的每一个key重新计算索引，插入新的哈希表，这个过程称为rehash。过程是这样的：

1.计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：
- 如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n
- 如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）
2.按照新的realeSize申请内存空间，创建dictht，并赋值给dict.ht[1]
3.设置dict.rehashidx = 0，标示开始rehash
4.将dict.ht[0]中的每一个dictEntry都rehash到dict.ht[1]
5.将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存

例如：现在有一个字典，字典里有两个dictht，dictht[0]存有4个entry。假设现在有一个新元素 k5=v5

在这里插入图片描述

在dictht[1]中创建大于5的第一个2的n次方的数组，修改size/sizemask/rehashidx/used

在这里插入图片描述

将dictht[0]的元素全部转移至dict[1]中，dictht[0]并指向新的dictEntry，dictht[1]设置为空

在这里插入图片描述

Dict的rehash并不是一次性完成的。试想一下，如果Dict中包含数百万的entry，要在一次rehash完成，极有可能导致主线程阻塞。因此Dict的rehash是分多次、渐进式的完成，因此称为渐进式rehash。流程如下：

1.计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：
- 如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^n
- 如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^n （不得小于4）
2.按照新的realeSize申请内存空间，创建dictht，并赋值给dict.ht[1]
3.设置dict.rehashidx = 0，标示开始rehash
~~4.将dict.ht[0]中的每一个dictEntry都rehash到dict.ht[1]~~
4.每次执行新增、查询、修改、删除操作时，都检查一下dict.rehashidx是否大于-1，如果是则将dict.ht[0].table[rehashidx]的entry链表rehash到dict.ht[1]，并且将rehashidx++。直至dict.ht[0]的所有数据都rehash到dict.ht[1]
5.将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存
6.将rehashidx赋值为-1，代表rehash结束
7.在rehash过程中，新增操作，则直接写入ht[1]，查询、修改和删除则会在dict.ht[0]和dict.ht[1]依次查找并执行。这样可以确保ht[0]的数据只减不增，随着rehash最终为空