Redis-学习之字典类型

学习字典类型，我们需要学习redis的hash，因为字典是基于hash进行分装的，如下图

我们从图中可以看出：dict 里面包含了一个ht ；ht有两个ht0 和ht1 ，为啥有两个后面再说，先看ht0中是一个 dictht, ditht 的table里面就是我们dictentry数组，dictEnry就是一个hash表结构k,v;

hash 结构

先看一下hash的代码：
哈希表节点使用dictEntry结构表示，每个dictEntry结构都保存着一个键值对：

typedef struct dictEntry {
    // 键
    void *key;
    // 值
    union{
        void *val;
        uint64_tu64;
        int64_ts64;
    } v;
    // 指向下个哈希表节点，形成链表 （hash 冲突，链地址法）
    struct dictEntry *next;
} dictEntry;

dictEntry中的一个键（ void *key;）值（union{
void *val;
uint64_tu64;
int64_ts64;
} v;）对。

Redis字典所使用的哈希表由dict.h/dictht结构定

代码如下

typedef struct dictht {
    // 哈希表节点组成的数组
    dictEntry **table; // 
    // 哈希表大小
    unsigned long size;
    //哈希表大小掩码，用于计算索引值 总是等于size-1
    unsigned long sizemask;
    // 该哈希表已有节点的数量（非null节点）
    unsigned long used;
} dictht;

从这个图我们看出 used 的值表示已有节点的数量，包括我们一个桶位上hash冲突后形成链表后进行统计后的值

总结：对于hash表而言，最上层是以 dictht 这个结构进行的定义，在这个结构里，有 dictEntry 来代表了我们的节点，节点中保存了 我们 key 和 value的对应。

字 典

字典：是基于 hash 表的结构上，再次进行的一层封装。

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

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

type属性

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

我们之前说过的ht有两个，h0和h1 ，为啥会有两个呢？

ht属性是一个包含两个哈希表的数组，数组中的每个项都是一个dictht哈希表，一般情况下，字典只使用ht[0]哈希表，ht[1]哈希表只会在对ht[0]哈希表进行rehash时使用。
除了ht[1]之外，另一个和rehash有关的属性就是rehashidx，它记录了rehash目前的进度，如果目前没有在进行rehash，那么它的值为-1。

rehashidx 他在我们hash特别大的时候可以记录我们 rehash的进度，相当于我们一个分批进行rehash，不会因数据量太大，造成io阻塞

redis中hash的哈希算法

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

1. 通过 dictType 里边的第一个 方法： 
    // 先计算哈希值的函数
    int hashValue = unsigned int (*hashFunction)(const void *key);
   
2. 哈希值再与我们的 sizemask 。
        最终的hash 值 = hashValue &  ht[x].sizemask。

rehash

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

扩展和收缩哈希表的工作可以通过执行rehash（重新散列）操作来完成，Redis对字典的哈希表执行rehash的步骤如下：
1）为字典的dict.ht[1]哈希表分配空间
·如果执行的是扩展操作，*那么ht[1]的大小为第一个大于等于ht[0].used*2的2 ^n（2的n次方幂）*；
      ht0 中 used = 10；为ht1分配的大小是 10*2 = 20？2的4次方是 16， 2的 5次方是 32. 32 是第一个大于 20的并且是 2 的 n次幂，所以 ht1的空间分配大小为 32。
·如果执行的是收缩操作，*那么ht[1]的大小为第一个大于等于ht[0].used的2^ n*。
     ht0 中 used = 10，那么 2的 4次方是 16， 16是第一个大于10的并且未 2的 n次幂的数字，所以此时 ht1的空间分配大小为 16.

2）将保存在ht[0]中的所有键值对rehash到ht[1]上面。 dictTyppe里边的第一个函数结果 & sizemask （如果是扩展，sizemask = 31； 如果是收缩，sizemask = 15）

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

rehash的触发时机 ，通过负载因子来进行扩展收缩

当以下条件中的任意一个被满足时，程序会自动开始对哈希表执行扩展操作：
1）服务器目前没有在执行BGSAVE命令或者BGREWRITEAOF命令，并且哈希表的负载因子大于等于1。
比如，我的hash表 size是 8， 现在有10个used（有hash冲突，肯定有链表结构），此时负载因子是 10 /8=1.25 > 1 。并且没有bgsvae和 reWaof，此时触发 扩展 rehash。
2）服务器目前正在执行BGSAVE命令或者BGREWRITEAOF命令，并且哈希表的负载因子大于等于5。
比如 我的hash表 size是 8， 现在有10个used（有hash冲突，肯定有链表结构），此时负载因子是 10 /8=1.25 > 1 ，这时候，由于有 bg和 bgre，所以不能触发。 但是随着时间的推移，我的 used 变成了 80， 此时负载因子是 80/8=10. 及时现在有bg和rebg，还是可以触发 rehash。

**其中哈希表的负载因子可以通过公式**：
# 
负载因子= 
哈希表已保存节点数量/ 
哈希表大小
load_factor = ht[0].used / ht[0].size

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

收缩：当哈希表的负载因子小于0.1时，程序自动开始对哈希表执行收缩操作。比如原来我有 11 个 used，size是16，现在变成1 个used了，size还是 16. 之前负载因子是 11/16 = 0.7 ; 现在是 1 / 16 < 0.1 . 此时触发 rehash、

##rehash是一个渐进式的过程

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

这样做的原因在于，如果哈希表里保存的键值对数量不是三四个，而是四百万、四千万甚至四亿个键值对，那么要一次性将这些键值对全部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属性的值增一。每迁移一个
keyvalue，就需要在 rehashidx 上自增 1. 如果有10万个值，我们 rehashidx会从0自增到 10万结束。
4）随着字典操作的不断执行，最终在某个时间点上，ht[0]的所有键值对都会被rehash至ht[1]，这时程序将rehashidx属性的值设为-1，表示rehash操作已完成。包括之前所说的
，ht1成为了 ht0，再重新创建一个空的 ht1备用。