redis源码阅读--三-redis散列表的实现

环境说明：redis源码版本 5.0.3；我在阅读源码过程做了注释，git地址：https://gitee.com/xiaoangg/redis_annotation

参考书籍：《redis的设计与实现》

redis  dict实现源码主要位于dict.c和dict.h中；

一.dict主要结构体

• dich.h/dictEntry结构体用于存储一个键值对;属性key键名称；val是联合体，用于存储值；next是指向下一节点的指针，当多个hash值同，

  //hash表节点 保存了一个键值对
  typedef struct dictEntry {
      void *key; //键
      union {
          void *val;
          uint64_t u64;
          int64_t s64;
          double d;
      } v; //值
      struct dictEntry *next; //下一节点（用来解决hash冲突）
  } dictEntry;
  
  

   

• dict.h/dictType保存 用于操作特定键值对的函数

typedef struct dictType {
    uint64_t (*hashFunction)(const void *key);       //计算hash值的函数（散列函数）
    void *(*keyDup)(void *privdata, const void *key);//复制键的函数 duplicate
    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;

• dict.h/dictht hash表节点。每个字典会有两个dictht结构体，用于rehash操作
   

  /* This is our hash table structure. Every dictionary has two of this as we
   * implement（实施） incremental（增量） rehashing, for the old to the new table. */
  typedef struct dictht {
      dictEntry **table; //hash 表数组
      unsigned long size;     //hash表大小 即dictEntry数组table的大小
      unsigned long sizemask; //hash表大小掩码，用于计算索引值，总是等于size-1
      unsigned long used; //hash表已经使用的大小
  } dictht;

   

• dict.h/dict 

  typedef struct dict {
      dictType *type;
      void *privdata; //私有数据
      dictht ht[2];   //一般只使用ht[0]， 对ht[0]进行rehash时会使用hs[1]
      long rehashidx; /* rehashing not in progress if rehashidx == -1 */ //rehash时记录进度
      unsigned long iterators; /* number of iterators currently running */
  } dict;
  

   

这四个结构体的程序结构图如下，更容易理解：
 

 

二.散列函数

   散列函数在散列表中起着非常关键的作用。key值经过散列函数计算得到的散列值。redis dict的散列函数在dict.c中;

   redis使用murmurhash2算法来计算hash值。关于murmurhash算法更过信息可以参考https://github.com/aappleby/smhasher

uint64_t dictGenHashFunction(const void *key, int len) {
    return siphash(key,len,dict_hash_function_seed);
}

三.散列冲突

几乎无法找到一个完美的无冲突的散列函数；散列冲突解决方法有两类，开放寻址法（open addressing）和链表法（chaining）。

1. 开放寻址法
开放寻址法的核心思想是，如果出现了散列冲突，我们就重新探测一个空闲位置，将其插入。

线性探测法（Linear Probing）：
当往散列表中插入数据时，如果某个数据经过散列函数散列之后，存储位置已经被占用了，就从当前位置开始，依次往后查找，看是否有空闲位置，直到找到为止。
问题：对于使用线性探测法解决冲突的散列表，删除操作稍微有些特别。不能单纯地把要删除的元素设置为空。因为在查找的时候，一旦通过线性探测方法，找到一个空闲位置，就可以认定散列表中不存在这个数据。但是，如果这个空闲位置是后来删除的，就会导致原来的查找算法失效。本来存在的数据，会被认定为不存在。这个问题我们可以将删除的元素，特殊标记为 deleted。当线性探测查找的时候，遇到标记为 deleted 的空间，并不是停下来，而是继续往下探测。

二次探测法（Quadratic probing）：二次探测，跟线性探测很像，线性探测每次探测的步长是 1，那它探测的下标序列就是 hash(key)+0，hash(key)+1，hash(key)+2……而二次探测探测的步长就变成了原来的“二次方”，也就是说，它探测的下标序列就是  hash(key)+0，hash(key)+1^2，hash(key)+2^2……

双重散列（Double hashing）：双重散列，意思就是不仅要使用一个散列函数。我们使用一组散列函数 hash1(key)，hash2(key)，hash3(key)……我们先用第一个散列函数，如果计算得到的存储位置已经被占用，再用第二个散列函数，依次类推，直到找到空闲的存储位置。

 

2. 链表法
在散列表中，每个“桶（bucket）”或者“槽（slot）”会对应一条链表，所有散列值相同的元素我们都放到相同槽位对应的链表中。

图来自极客时间

3. redis是如何解决散列冲突的
redis使用的是链表法 来解决散列冲突的；

dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
{
    long index;
    dictEntry *entry;
    dictht *ht;

    //判断hash表是否正在rehash 
    if (dictIsRehashing(d)) _dictRehashStep(d);

    //判断key是否已经存在 ==-1key已经存在 
    /* Get the index of the new element, or -1 if
     * the element already exists. */
    if ((index = _dictKeyIndex(d, key, dictHashKey(d,key), existing)) == -1)
        return NULL;

    /* Allocate the memory and store the new entry.
     * Insert the element in top, with the assumption that in a database
     * system it is more likely that recently added entries are accessed
     * more frequently. */
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = zmalloc(sizeof(*entry));
    //使用链表法解决hash冲突
    entry->next = ht->table[index];
    ht->table[index] = entry;  
    ht->used++;

    /* Set the hash entry fields. */
    dictSetKey(d, entry, key);
    return entry;
}

 

附：dictAdd程序流程图
https://download.csdn.net/download/qq_16399991/12014033

dictDel程序流程图