Redis数据结构-字典

字典

Redis的数据库使用字典作为底层实现，对数据库的增删查改操作也是构建在字典的操作上的。字典也是哈希键的底层实现之一，当一个哈希键包含的键值对较多，或者键值对中的元素都是比较长的字符串时，Redis就使用字典作为哈希键的底层实现。

字典的实现

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

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

   typedef  struct dictht{
       //哈希表数组，每个元素都是指向一个dictEntry结构的指针
       dictEntry **table;
       //哈希表大小
       unsigned long size;
       //哈希表大小掩码，用于计算索引值，总是等于size-1，和哈希值共同决定一个键被放在哪个索引上        
       unsigned long sizemask;
       //该哈希表已有节点的数量
       unsigned long used;
   }dictht;

2. 哈希表节点：由dict.h/dictEntry结构表示，每个都保存着一个键值对：

   typedef sturct dictEntry{
       //键
       void *key;
       //值
       union{
           void *val;
           uint64_t u64;
           int64_t  s64;
       }v;
       //指向下一个哈希表节点，形成链表，将多个哈希值相同的键值对连接在一起，解决键冲突问题
       struct dictEntry *next;
   } dictEntry;

3. 字典：由dict.h/dict结构表示：

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

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

   • 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属性是一个包含两个dictht哈希表。一般情况下，字典只使用ht[0]哈希表，ht[1]哈希表只会在对ht[0]哈希表进行rehash时使用。rehashidx记录了rehash进度，如果没有进行rehash，那么它的值为-1。

哈希算法

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

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

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

解决键冲突

Reis的哈希表采用链地址法来解决键冲突，每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的节点可以用单向链表连接起来，解决键冲突问题。为了速度考虑，程序总将新的节点添加到表头（复杂度O(1)）。

rehash

为了使哈希表的负载因子维持一个合理范围，当哈希表保存的键值对数量太多或者太少时，程序对哈希表进行相应地扩展或者收缩。

• 为字典的ht[1]哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及ht[0]当前包含的键值对数量

  • 如果执行的是扩展操作，那么ht[1]的大小为第一个大于等于ht[0].used*2的2^n
  • 如果执行的是收缩操作，那么ht[1]的大小为第一个大于等于ht[0].used的2^n

• 将保存在ht[0]中的所有键值对rehash到ht[1]上面：rehash指的是重新计算键的hash值和索引值，然后将键值对放在ht[1]的指定位置上

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

哈希表扩展与收缩的条件：

当一下任意条件满足时，程序自动执行扩展操作：

• 服务器目前没有执行BGSAVE 或者 BGREWRITEAOF 命令，并且哈希表的负载因子大于等于1
• 服务器目前正在执行 BGSAVE 或者 BGREWRITEAOF 命令，并且哈希表的负载因子大于等于5

哈希表负载因子计算方法：

load_factor = ht[0].used / ht[0].size

根据BGSAVE 或者 BGREWRITEAOF 命令是否在执行，服务器执行扩展操作所需的负载因子不相同，因为执行这两条命令时，Redis需要创建子进程，而大多数操作系统采用写时复制技术优化子进程使用效率，所以子进程存在期间服务器提高执行扩展操作所必须的负载因子，从而尽可能的避免在子进程存在期间进行哈希表扩展操作，可以避免不必要的内存写入操作，最大限度解约内存。
另一方面，当哈希表的负载因子小于0.1时，程序自动执行收缩操作

渐进式rehash

rehash动作是分多次、渐进性的完成的，目的是防止size非常巨大的哈希表一次性rehash造成的庞大计算量导致服务器一段时间停止服务。哈希表渐进式rehash的步骤：

• 为ht[1]分配空间，让字典同时持有ht[0]和ht[1]两个哈希表
• 在字典中维持一个索引计数器rehashidx，将它设置为0，表示rehash正式开始
• 在执行rehash期间，每次对字典执行添加、删除、查找或者更新操作时，程序还会顺带将ht[0]哈希表在rehashidx索引上的所有键值对rehash到ht[1]上，当rehash完成后，rehashidx的值加1
• 随着字典操作不断执行，最终在某个时间点，ht[0]的所有键值对都被rehash到ht[1]，当rehash完成时，rehashidx的值设置为-1，表示rehash操作完成

渐进式rehash操作采用分而治之的方式，将rehash键值对所需的计算工作均摊到每次对字典的操作上，从而避免集中式rehash带来的庞大运算量。

渐进式rehash执行期间的哈希表操作

由于在渐进式rehash进行过程中，字典同时使用ht[0]和ht[1]两个哈希表，所以字典的删除、查找、更新等操作会在两个哈希表执行。