携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第4天，点击查看活动详情 >>

redis数据结构——Dict

Dict的定义

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

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

下面分别给出redis中哈希表、哈希节点、字典的定义结构体：

哈希表（DictHashTable）：

typedef struct dictht {  //dictht是DictHashTable的缩写
    // entry数组
    // 数组中保存的是指向entry的指针
    dictEntry **table; 
    // 哈希表大小
    unsigned long size;     
    // 哈希表大小的掩码，总等于size - 1
    unsigned long sizemask;     
    // entry个数
    unsigned long used; 
} dictht;

哈希节点（DictEntry）：

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

字典（Dict）：

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

Dict的结构图

正如上图所示，当我们向Dict添加键值对时，Redis首先根据key计算出hash值（h），然后利用 h & sizemask来计算元素应该存储到数组中的哪个索引位置。我们存储k1=v1，假设k1的哈希值h =1，则1&3 =1，因此k1=v1要存储到数组角标1位置。此后如果还有键哈希值为1的话，就采用队头插入法。

其实上图只是Dict中的一部分，相信有认真阅读上面DIct结构体定义的你一定会发现，在dict结构体中定义了两个dictht。

通过上图可以看到ht[0]是真正存放数据的，而ht[1]是置空的，为什么需要这样设置呢？

嘿嘿，别着急，我们后面会聊到的。

Dict的扩容

结合上面我们所谈及的，到这里大家应该都知道Dict的HashTable是通过数组 + 单向链表来实现的。

当装入的元素相对集中的时候，就会频繁产生哈希冲突，会导致单链表的长度过长，导致整个值的查询效率大大降低。这个时候就要适当地进行哈希表扩容了。

其实Dict在每次新增键值对时都会检查负载因子（LoadFactor = used/size），满足以下两种情况时会触发哈希表扩容：（负载因子 = 当前哈希表中有的结点数 / 哈希数组的长度）

触发哈希扩容：

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

哈希表的 LoadFactor > 5 ；

下面可以看看源码的具体实现：

static int _dictExpandIfNeeded(dict *d){
    // 如果正在rehash，则返回ok
    if (dictIsRehashing(d)) return DICT_OK;    // 如果哈希表为空，则初始化哈希表为默认大小：4
    if (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^n
        return dictExpand(d, d->ht[0].used + 1);
    }
    return DICT_OK;
}

因为执行 BGSAVE 或者 BGREWRITEAOF 等后台进程会很影响效率的，所以如果此时 1 <= LoadFactor <= 5，且有上述后台进程是，Dict选择容忍一下，不进行扩容；可是如果此时LoadFactor > 5 了，Dict已经忍无可忍了，必须立马扩容（寻找大于等于当前 used+1 的 2^n）。

触发哈希收缩：

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

每次删除元素成功后，检查是否需要重置Dict大小，如果需要则调用dictResize重置：

// 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);
}

htNeedsResize(dict *dict)函数是为了检查当前负载因子是否小于0.1，小于0.1返回true，否则false。

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

dictResize(dict *d)是哈希收缩的实现过程：

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，则重置为4
    if (minimal < DICT_HT_INITIAL_SIZE)
        minimal = DICT_HT_INITIAL_SIZE;
    // 重置大小为minimal，其实是第一个大于等于minimal的2^n
    return dictExpand(d, minimal);
}

Dict的rehash

无论是哈希扩容还是收缩，都肯定会创建新的哈希表，导致哈希表的size和sizemask变化（数组的长度发生了变化，从而会引起部分key的哈希值的改变），也正因为这样，所以在扩容或者收缩之后，必须对哈希表中的每一个key重新计算索引，插入新的哈希表，这个过程称为rehash。

rehash过程：

1. 先计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：


    如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^𝑛

    如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^𝑛  （不得小于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[0]指向dict.ht[1]的地址空间），将dict.ht[1]的重新指向空

其实熟悉c语言的朋友应该很容易理解，上述过程简单点来说就是：将先将dict.ht[0]中的值复制到dict.ht[1]的对应空间中，待所有值复制完毕后，就可以让整个dict.ht[0]指向dict.ht[1]了，此时访问dict.ht[0]就访问到得到复制数据后的dict.ht[1]了，又因为Dict中需要两个ht，所以只需要在将ht[1]重新置空，就可以为下一次rehash提供条件。

相信看到这里的朋友都明白为什么前面dict定义的时候为什么需要定义两个ht了吧

redis是一个适用于高并发，多数据场景的键值对型数据库，假如现在的Dict中具有很多很多数据，那么在进行上述rehash过程的时候将会很耗费时间，在rehash过程中，其他服务的提供受到影响，持续时间较长，影响很大；为此提出了渐进式rehash。

渐进式rehash并不是一次将dict.ht[0]中的数据rehash到dict.ht[1]中的，而是分多次，多步完成。

渐进式rehash

1. 先计算新hash表的realeSize，值取决于当前要做的是扩容还是收缩：


    如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2^𝑛

    如果是收缩，则新size为第一个大于等于dict.ht[0].used的2^𝑛  （不得小于4）

2. 按照新的realeSize申请内存空间，创建dictht，并赋值给dict.ht[1]
3. 设置dict.rehashidx = 0，标示开始rehash
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最终为空

【redis数据结构】五分钟带你由浅入深学习Dict

redis数据结构——Dict

Dict的定义

Dict的结构图

Dict的扩容

Dict的rehash