redis的字典使用哈希表作为底层实现，一个哈希表里面可以有多个哈希表，而每个哈希表节点就保存了字典中的一个键值对。
1.哈希表
typedef struct dictht { //哈希表 dictEntry **table; //存放一个数组的地址，数组存放着哈希表节点dictEntry的地址 unsigned long size; //哈希表table的大小.初始化大小是4 unsigned long sizemask; //用于将哈希值映射到table的位置索引,它的值总是等于size-1 unsigned long used; //记录哈希表已有的节点的数值 } dictht;
2.哈希表节点
typedef struct dictEntry { void *key; //key union { void *val; uint64_t u64; int64_t s64; double d; } v; //value struct dictEntry *next; //指向下一个节点的指针 } dictEntry;
3.字典
typedef struct dict { dictType *type; //指向dictType结构，dictType结构中包含自定义的函数，这些函数使得key和value能够存储任何类型的数据。 void *privdata; //私有数据 dictht ht[2]; //ht[0] ht[1] long rehashidx; /* rehashing not in progress if rehashidx == -1 */ int iterators; /* number of iterators currently running */ } dict; 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;
哈希结构图如图：
4.哈希算法
要将一个键值加入到字典里面，程序会先根据键值对的键计算出哈希值和索引值，然后再根据索引值，将包含新键值对的哈希表节点放到哈希表数组指定索引上面。
1.用于计算整型值的hash算法
/* Thomas Wang's 32 bit Mix Function */ unsigned int dictIntHashFunction(unsigned int key) { key += ~(key << 15); key ^= (key >> 10); key += (key << 3); key ^= (key >> 6); key += ~(key << 11); key ^= (key >> 16); return key; }
2.MurmurHash2哈希算法
优点是：即使输入的键是有规律的，算法仍能给出一个很好的随机分布性，并且算法的计算速度也非常快
//MurmurHash2哈希算法 unsigned int dictGenHashFunction(const void *key, int len) { /* 'm' and 'r' are mixing constants generated offline. They're not really 'magic', they just happen to work well. */ uint32_t seed = dict_hash_function_seed; const uint32_t m = 0x5bd1e995; const int r = 24; /* Initialize the hash to a 'random' value */ uint32_t h = seed ^ len; /* Mix 4 bytes at a time into the hash */ const unsigned char *data = (const unsigned char *)key; while(len >= 4) { uint32_t k = *(uint32_t*)data; k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; data += 4; len -= 4; } /* Handle the last few bytes of the input array */ switch(len) { case 3: h ^= data[2] << 16; case 2: h ^= data[1] << 8; case 1: h ^= data[0]; h *= m; }; /* Do a few final mixes of the hash to ensure the last few * bytes are well-incorporated. */ h ^= h >> 13; h *= m; h ^= h >> 15; return (unsigned int)h; }
3.djb哈希算法
算法的思想是利用字符串中的ascii码值与一个随机seed，通过len次变换，得到最后的hash值。
//djb哈希算法 unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) { unsigned int hash = (unsigned int)dict_hash_function_seed; while (len--) hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */ return hash; }
5.解决键冲突
如果是有键值对被分配到哈希表数组的同一个索引上面，redis的哈希表利用链表地址法，每一个哈希表节点都有一个next指针，多个哈希表节点都有一个next指针，多个哈希表可以用next指针构成一个单链表，被分配到同一个索引上的多个节点可以用这个单向链表连接起来。也就是哈希链表(忘记是在那本书上看到过还是哪个学长讲过)
6.rehash
rehash是随着操作的不断执行，哈希表保存的键值对会逐渐增多或减少，为了使哈希表的负载因子维持在一个合理的范围内，当哈希表保存饿键值对数量太多或者太少时，程序都要对哈希表进行rehash。
rehash分为三步：
1.为ht[1]分配合适空间大小；
如果是执行的扩容操作ht[1]分配的空间大小是第一个大于等于ht[0].used*2的 pow(2,n);
如果是执行的缩容操作ht[1]分配的空间大小是第一个大于等于ht[0].used的pow(2,n);
2.将ht[0]中所有的键值对重新计算键的hash值和索引值，然后将键值对放置到ht[1]上；
3.当所有的ht[0]都迁移到ht[1]之后，释放ht[0],将ht[1]置为ht[0]，并给ht[1]新创建一个空的hash表
程序会自动rehash操作：
1.服务器目前没有在执行bgsave命令或者bgrewriteaof命令，并且哈希表的负载因子大于等于1；
2.服务器目前在执行bgsave命令或者bgrewriteaof命令，并且哈希表的负载因子大于等于5；
负载因子load_factor = ht[0].used / ht[0].size
//根据size调整d的哈希表 int dictExpand(dict *d, unsigned long size) { dictht n; /* the new hash table */ unsigned long realsize = _dictNextPower(size); // 获取第一个pow(2,x) 大于size的数 /* the size is invalid if it is smaller than the number of * elements already inside the hash table */ //dictIsRehashing查看当前dict是否在rehash //已有键值对的数量大于size if (dictIsRehashing(d) || d->ht[0].used > size) return DICT_ERR; /* Rehashing to the same table size is not useful. */ if (realsize == d->ht[0].size) return DICT_ERR; /* Allocate the new hash table and initialize all pointers to NULL */ n.size = realsize; n.sizemask = realsize-1; n.table = zcalloc(realsize*sizeof(dictEntry*)); n.used = 0; /* Is this the first initialization? If so it's not really a rehashing * we just set the first hash table so that it can accept keys. */ if (d->ht[0].table == NULL) { d->ht[0] = n; return DICT_OK; } /* Prepare a second hash table for incremental rehashing */ d->ht[1] = n; d->rehashidx = 0; return DICT_OK; }
7.渐进式rehash
哈希表渐进式rehash步骤:
1.为ht[1]分配空间，让字典同时拥有ht[0]和ht[1]两个哈希表；
2.在字典中维持一个索引计数器变量，rehashidx,并将值值为0，表示rehash开始；
3.在rehash期间，每次对字典执行增删查改操作时，程序除了执行指定的操作，还会顺带将ht[0]哈希表在rehashidx索引上的所有键值对rehash到ht[1]，当rehash完成后，程序将rehashidx属性值增一；
4.随着字典操作的不断执行，最终在某个时间点上ht[0]的所有键值对都会被rehash到ht[1]，这时程序会讲rehashidx属性值为-1；
渐进式rehash将rehash键值所需的计算工作均摊到对字典的操作上，从而避免集中式rehash带来庞大的计算量。
//单步迭代 只有在dict的索引为0时开始 static void _dictRehashStep(dict *d) { if (d->iterators == 0) dictRehash(d,1); } //n步进行rehash int dictRehash(dict *d, int n) { int empty_visits = n*10; /* Max number of empty buckets to visit. */ if (!dictIsRehashing(d)) return 0; while(n-- && d->ht[0].used != 0) { dictEntry *de, *nextde; /* Note that rehashidx can't overflow as we are sure there are more * elements because ht[0].used != 0 */ assert(d->ht[0].size > (unsigned long)d->rehashidx); //dictEntry[rehashidx] 不为空 while(d->ht[0].table[d->rehashidx] == NULL) { d->rehashidx++; if (--empty_visits == 0) return 1; } de = d->ht[0].table[d->rehashidx]; /* Move all the keys in this bucket from the old to the new hash HT */ //遍历hash table[rehashidx]的全链表 while(de) { unsigned int h; nextde = de->next; /* Get the index in the new hash table */ h = dictHashKey(d, de->key) & d->ht[1].sizemask; de->next = d->ht[1].table[h]; //插入到表头 d->ht[1].table[h] = de; d->ht[0].used--; d->ht[1].used++; de = nextde; } d->ht[0].table[d->rehashidx] = NULL; d->rehashidx++; } /* Check if we already rehashed the whole table... */ if (d->ht[0].used == 0) { zfree(d->ht[0].table); d->ht[0] = d->ht[1]; _dictReset(&d->ht[1]); d->rehashidx = -1; return 0; } /* More to rehash... */ return 1; }