原作者: 爱宝贝丶

  1.   dict又称为字典，redis整个数据库结构其实就是一个dict，比如执行set msg "Hello World!"，那么其存储数据的dict中就有一个键为sds结构的字符串"msg"，而值则为字符串"Hello World!"。并且在redis中命令与其对应的执行函数也是用dict存储的。dict的具体数据结构如下
  1. typedef struct dict {
  2.     // 类型特定函数
  3.     dictType *type;
  4.     // 私有数据
  5.     void *privdata;
  6.     // 哈希表
  7.     dictht ht[2];
  8.     // rehash 索引
  9.     // 当 rehash 不在进行时，值为 -1
  10.     int rehashidx;
  11.     // 目前正在运行的安全迭代器的数量
  12.     int iterators;
  13. } dict;
  1.   其中type存储了hash函数，key和value的复制，比较以及销毁函数，而privdata则保存了一些私有数据，其和type共同决定了当前dictType结构中所保存的函数的指向，从而实现多态的目的，比如redis提供的hash函数就有两种，一种是Murmurhash函数，另一种是djbhash函数。dictType的具体结构如下：
  1. typedef struct dictType {
  2.     // 计算哈希值的函数
  3.     unsigned int (*hashFunction)(const void *key);
  4.     // 复制键的函数
  5.     void *(*keyDup)(void *privdata, const void *key);
  6.     // 复制值的函数
  7.     void *(*valDup)(void *privdata, const void *obj);
  8.     // 对比键的函数
  9.     int (*keyCompare)(void *privdata, const void *key1, const void *key2);
  10.     // 销毁键的函数
  11.     void (*keyDestructor)(void *privdata, void *key);
  13.     // 销毁值的函数
  14.     void (*valDestructor)(void *privdata, void *obj);
  15. } dictType;
  1.   dictht类型对象ht是一个长度为2的数组，正常情况下回使用ht[0]来存储数据，当进行rehash操作时，redis会使用ht[1]来配合进行渐进式rehash操作，而rehashidx是一个整数值，如果当前没有进行rehash操作，则其值为-1，如果正在进行rehash操作，那么其值为当前rehash操作正在执行到的ht[1]中dictEntry数组的索引。dictht的具体数据结构如下：
  1. typedef struct dictht {
  3.     // 哈希表数组
  4.     dictEntry **table;
  5.     // 哈希表大小
  6.     unsigned long size;
  8.     // 哈希表大小掩码，用于计算索引值
  9.     // 总是等于 size - 1
  10.     unsigned long sizemask;
  11.     // 该哈希表已有节点的数量
  12.     unsigned long used;
  13. } dictht;
  1.   dictht结构中dictEntry中主要存储了key和value的值。size为当前table数组的大小，其由于要经常对hash值与size进行取模运算，而取模运算可以优化为(size - 1) & h，速度上得到了提高，但这要求size为2的倍数，因而会将size的值设置为2的倍数。sizemask则为size减一，用于优化一些后续的运算。used属性存储了当前dictht结构中存储的键值对的数量。以下是dictEntry的存储结构：
  1. typedef struct dictEntry {
  3.     // 键
  4.     void *key;
  5.     // 值
  6.     union {
  7.         void *val;
  8.         uint64_t u64;
  9.         int64_t s64;
  10.     } v;
  11.     // 指向下个哈希表节点，形成链表
  12.     struct dictEntry *next;
  13. } dictEntry;
  1.   dictEntry中的key保存有dict的键，而val则保存了值，u64保存了无符号64位的整型，s64保存了有符号64位整型，next则表示该结构为单链存储键值对以解决hash冲突的问题。<br />      dict中的iterators标识了当前hash表中正在安全运行的迭代器的数量，如果其值不为0，那么是不允许对hash表进行rehash操作的。下图展示了保存有四个节点的hash表的存储结构：<br />![](https://cdn.nlark.com/yuque/0/2019/png/383291/1563776898652-590fd6c5-c2cb-46f8-8c3f-5d2e0e4365a6.png#align=left&display=inline&height=392&originHeight=392&originWidth=396&size=0&status=done&width=396)<br />      redis采用的hash算法是Murmurhash算法，该算法的特点是即使输入的键是很有规律的也能将其值进行很好的散列，关于该算法具体的描述读者可以查阅相关的文献资料，这里贴出其具体的代码：
  1. unsigned int dictGenHashFunction(const void *key, int len) {
  2.     /* 'm' and 'r' are mixing constants generated offline.
  3.      They're not really 'magic', they just happen to work well.  */
  4.     uint32_t seed = dict_hash_function_seed;
  5.     const uint32_t m = 0x5bd1e995;
  6.     const int r = 24;
  7.     /* Initialize the hash to a 'random' value */
  8.     uint32_t h = seed ^ len;
  9.     /* Mix 4 bytes at a time into the hash */
  10.     const unsigned char *data = (const unsigned char *)key;
  11.     while(len >= 4) {
  12.         uint32_t k = *(uint32_t*)data;
  13.         k *= m;
  14.         k ^= k >> r;
  15.         k *= m;
  16.         h *= m;
  17.         h ^= k;
  18.         data += 4;
  19.         len -= 4;
  20.     }
  21.     /* Handle the last few bytes of the input array  */
  22.     switch(len) {
  23.     case 3: h ^= data[2] << 16;
  24.     case 2: h ^= data[1] << 8;
  25.     case 1: h ^= data[0]; h *= m;
  26.     };
  27.     /* Do a few final mixes of the hash to ensure the last few
  28.      * bytes are well-incorporated. */
  29.     h ^= h >> 13;
  30.     h *= m;
  31.     h ^= h >> 15;
  32.     return (unsigned int)h;
  33. }
  1.   由于redis是进行大数据量存储的nosql数据库，如果当前存储的数据量非常大，但是hash表的容量不够，此时就要对hash表进行扩容，如果进行一次性扩容并且进行数据迁移的话将导致在一段时间内服务器不能处理其他的请求。为了解决这个问题，redis采用了渐进式rehash的操作。渐进式rehash的思想是将hash表中的数据进行分步rehash，比如有1000w条数据，那么分20次每次rehash 50w条数据，这样就可以将全部的数据rehash完成。具体的，redis的渐进式rehash是每次将dictht中dictEntry数组的一个节点上的链表进行rehash操作，而其是在每次进行添加，删除，查询等操作是进行一次，从而将dictEntry数组的每一个节点都散列完成为止。rehash具体的代码如下：
  1. int dictRehash(dict *d, int n) {
  2.     // 只可以在 rehash 进行中时执行
  3.     if (!dictIsRehashing(d)) return 0;
  4.     // 进行 N 步迁移
  5.     // T = O(N)
  6.     while(n--) {
  7.         dictEntry *de, *nextde;
  8.         /* Check if we already rehashed the whole table... */
  9.         // 如果 0 号哈希表为空，那么表示 rehash 执行完毕
  10.         // T = O(1)
  11.         if (d->ht[0].used == 0) {
  12.             // 释放 0 号哈希表
  13.             zfree(d->ht[0].table);
  14.             // 将原来的 1 号哈希表设置为新的 0 号哈希表
  15.             d->ht[0] = d->ht[1];
  16.             // 重置旧的 1 号哈希表
  17.             _dictReset(&d->ht[1]);
  18.             // 关闭 rehash 标识
  19.             d->rehashidx = -1;
  20.             // 返回 0 ，向调用者表示 rehash 已经完成
  21.             return 0;
  22.         }
  23.         /* Note that rehashidx can't overflow as we are sure there are more
  24.          * elements because ht[0].used != 0 */
  25.         // 确保 rehashidx 没有越界
  26.         assert(d->ht[0].size > (unsigned)d->rehashidx);
  27.         // 略过数组中为空的索引，找到下一个非空索引
  28.         while(d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++;
  29.         // 指向该索引的链表表头节点
  30.         de = d->ht[0].table[d->rehashidx];
  31.         /* Move all the keys in this bucket from the old to the new hash HT */
  32.         // 将链表中的所有节点迁移到新哈希表
  33.         // T = O(1)
  34.         while(de) {
  35.             unsigned int h;
  36.             // 保存下个节点的指针
  37.             nextde = de->next;
  38.             /* Get the index in the new hash table */
  39.             // 计算新哈希表的哈希值，以及节点插入的索引位置
  40.             h = dictHashKey(d, de->key) & d->ht[1].sizemask;
  41.             // 插入节点到新哈希表
  42.             de->next = d->ht[1].table[h];
  43.             d->ht[1].table[h] = de;
  44.             // 更新计数器
  45.             d->ht[0].used--;
  46.             d->ht[1].used++;
  47.             // 继续处理下个节点
  48.             de = nextde;
  49.         }
  50.         // 将刚迁移完的哈希表索引的指针设为空
  51.         d->ht[0].table[d->rehashidx] = NULL;
  52.         // 更新 rehash 索引
  53.         d->rehashidx++;
  54.     }
  55.     return 1;
  56. }
  1.   从上述代码中可以看出，当进行rehash时，首先会将dict.rehashidx置为0，用于开始对dict.ht[0].table[0]的链表进行rehash，当一次rehash完成时，会将dict.rehashidx的值自增一位。渐进式rehash时会将dict.ht[1].table的长度设置为比要扩展的size大的2的倍数，对每个键值对进行rehash时会将其散列到dict.ht[1]中，也就是说当渐进式rehash进行时，dict.ht[0]和dict[1]中都保存有真实的数据。虽然数据保存在了两个dictht对象中，但是在渐进式rehash执行时，用户进行的添加，删除和查找等操作都会对两个表进行查找。当渐进式rehash完成时，服务器会将dict.ht[0]指向dict.ht[1]的值，并且释放dict.ht[1]的对象，并且将dict.rehashidx的值置为-1。<br />      redis服务器会在以下两种情况下进行渐进式rehash操作：
  • hash表的负载因子大于等于1，并且服务器没有执行bgsave或bgrewriteaof命令；

  • hash表的负载因子大于5；

    1. 具体的代码如下：
    1. static int _dictExpandIfNeeded(dict *d)
    2. {
    3.   // 渐进式 rehash 已经在进行了，直接返回
    4.   if (dictIsRehashing(d)) return DICT_OK;
    5.   // 如果字典（的 0 号哈希表）为空，那么创建并返回初始化大小的 0 号哈希表
    6.   // T = O(1)
    7.   if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
    8.   // 一下两个条件之一为真时，对字典进行扩展
    9.   // 1）字典已使用节点数和字典大小之间的比率接近 1：1
    10.   //    并且 dict_can_resize 为真
    11.   // 2）已使用节点数和字典大小之间的比率超过 dict_force_resize_ratio
    12.   if (d->ht[0].used >= d->ht[0].size &&
    13.       (dict_can_resize ||
    14.        d->ht[0].used/d->ht[0].size > dict_force_resize_ratio))
    15.   {
    16.       // 新哈希表的大小至少是目前已使用节点数的两倍
    17.       // T = O(N)
    18.       return dictExpand(d, d->ht[0].used*2);
    19.   }
    20.   return DICT_OK;
    21. }
    1. // 判断是否正在执行bgsave或bgrewriteaof命令
    2. void updateDictResizePolicy(void) {
    3.   if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
    4.       dictEnableResize();
    5.   else
    6.       dictDisableResize();
    7. }
    1. 另外还要说明的是，对于hash表的rehash操作，默认是采用分步式rehash操作，即每次rehash dictEntry数组一个索引的链表，如果进行了设置，则可以按照时间段进行rehash，在指定的时间段内每次rehash dictEntry数组的100项链表，直到指定的rehash时长到达，具体的代码如下：
    1. int dictRehashMilliseconds(dict *d, int ms) {
    2.   // 记录开始时间
    3.   long long start = timeInMilliseconds();
    4.   int rehashes = 0;
    5.   while(dictRehash(d,100)) {
    6.       rehashes += 100;
    7.       // 如果时间已过，跳出
    8.       if (timeInMilliseconds()-start > ms) break;
    9.   }
    10.   return rehashes;
    11. }
    1. 以上是redis中hash表的主要功能说明，而诸如添加，删除，修改和查询等操作的具体代码则和一般的hash表区别不大，这里将dict的全部代码贴出，以供读者查阅。
    1. /* Hash Tables Implementation.
    2. *
    3. * This file implements in-memory hash tables with insert/del/replace/find/
    4. * get-random-element operations. Hash tables will auto-resize if needed
    5. * tables of power of two in size are used, collisions are handled by
    6. * chaining. See the source code for more information... :)
    7. *
    8. * 这个文件实现了一个内存哈希表，
    9. * 它支持插入、删除、替换、查找和获取随机元素等操作。
    10. *
    11. * 哈希表会自动在表的大小的二次方之间进行调整。
    12. *
    13. * 键的冲突通过链表来解决。
    14. *
    15. * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez at gmail dot com>
    16. * All rights reserved.
    17. *
    18. * Redistribution and use in source and binary forms, with or without
    19. * modification, are permitted provided that the following conditions are met:
    20. *
    21. *   * Redistributions of source code must retain the above copyright notice,
    22. *     this list of conditions and the following disclaimer.
    23. *   * Redistributions in binary form must reproduce the above copyright
    24. *     notice, this list of conditions and the following disclaimer in the
    25. *     documentation and/or other materials provided with the distribution.
    26. *   * Neither the name of Redis nor the names of its contributors may be used
    27. *     to endorse or promote products derived from this software without
    28. *     specific prior written permission.
    29. *
    30. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    31. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    32. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    33. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    34. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    35. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    36. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    37. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    38. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    39. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    40. * POSSIBILITY OF SUCH DAMAGE.
    41. */
    42. #include <stdint.h>
    43. #ifndef __DICT_H
    44. #define __DICT_H
    45. /*
    46. * 字典的操作状态
    47. */
    48. // 操作成功
    49. #define DICT_OK 0
    50. // 操作失败（或出错）
    51. #define DICT_ERR 1
    52. /* Unused arguments generate annoying warnings... */
    53. // 如果字典的私有数据不使用时
    54. // 用这个宏来避免编译器错误
    55. #define DICT_NOTUSED(V) ((void) V)
    56. /*
    57. * 哈希表节点
    58. */
    59. typedef struct dictEntry {
    61.   // 键
    62.   void *key;
    63.   // 值
    64.   union {
    65.       void *val;
    66.       uint64_t u64;
    67.       int64_t s64;
    68.   } v;
    69.   // 指向下个哈希表节点，形成链表
    70.   struct dictEntry *next;
    71. } dictEntry;
    72. /*
    73. * 字典类型特定函数
    74. */
    75. typedef struct dictType {
    76.   // 计算哈希值的函数
    77.   unsigned int (*hashFunction)(const void *key);
    78.   // 复制键的函数
    79.   void *(*keyDup)(void *privdata, const void *key);
    80.   // 复制值的函数
    81.   void *(*valDup)(void *privdata, const void *obj);
    82.   // 对比键的函数
    83.   int (*keyCompare)(void *privdata, const void *key1, const void *key2);
    84.   // 销毁键的函数
    85.   void (*keyDestructor)(void *privdata, void *key);
    87.   // 销毁值的函数
    88.   void (*valDestructor)(void *privdata, void *obj);
    89. } dictType;
    90. /* This is our hash table structure. Every dictionary has two of this as we
    91. * implement incremental rehashing, for the old to the new table. */
    92. /*
    93. * 哈希表
    94. *
    95. * 每个字典都使用两个哈希表，从而实现渐进式 rehash 。
    96. */
    97. typedef struct dictht {
    99.   // 哈希表数组
    100.   dictEntry **table;
    101.   // 哈希表大小
    102.   unsigned long size;
    104.   // 哈希表大小掩码，用于计算索引值
    105.   // 总是等于 size - 1
    106.   unsigned long sizemask;
    107.   // 该哈希表已有节点的数量
    108.   unsigned long used;
    109. } dictht;
    110. /*
    111. * 字典
    112. */
    113. typedef struct dict {
    114.   // 类型特定函数
    115.   dictType *type;
    116.   // 私有数据
    117.   void *privdata;
    118.   // 哈希表
    119.   dictht ht[2];
    120.   // rehash 索引
    121.   // 当 rehash 不在进行时，值为 -1
    122.   int rehashidx; /* rehashing not in progress if rehashidx == -1 */
    123.   // 目前正在运行的安全迭代器的数量
    124.   int iterators; /* number of iterators currently running */
    125. } dict;
    126. /* If safe is set to 1 this is a safe iterator, that means, you can call
    127. * dictAdd, dictFind, and other functions against the dictionary even while
    128. * iterating. Otherwise it is a non safe iterator, and only dictNext()
    129. * should be called while iterating. */
    130. /*
    131. * 字典迭代器
    132. *
    133. * 如果 safe 属性的值为 1 ，那么在迭代进行的过程中，
    134. * 程序仍然可以执行 dictAdd 、 dictFind 和其他函数，对字典进行修改。
    135. *
    136. * 如果 safe 不为 1 ，那么程序只会调用 dictNext 对字典进行迭代，
    137. * 而不对字典进行修改。
    138. */
    139. typedef struct dictIterator {
    141.   // 被迭代的字典
    142.   dict *d;
    143.   // table ：正在被迭代的哈希表号码，值可以是 0 或 1 。
    144.   // index ：迭代器当前所指向的哈希表索引位置。
    145.   // safe ：标识这个迭代器是否安全
    146.   int table, index, safe;
    147.   // entry ：当前迭代到的节点的指针
    148.   // nextEntry ：当前迭代节点的下一个节点
    149.   //             因为在安全迭代器运作时， entry 所指向的节点可能会被修改，
    150.   //             所以需要一个额外的指针来保存下一节点的位置，
    151.   //             从而防止指针丢失
    152.   dictEntry *entry, *nextEntry;
    153.   long long fingerprint; /* unsafe iterator fingerprint for misuse detection */
    154. } dictIterator;
    155. typedef void (dictScanFunction)(void *privdata, const dictEntry *de);
    156. /* This is the initial size of every hash table */
    157. /*
    158. * 哈希表的初始大小
    159. */
    160. #define DICT_HT_INITIAL_SIZE     4
    161. /* ------------------------------- Macros ------------------------------------*/
    162. // 释放给定字典节点的值
    163. #define dictFreeVal(d, entry) \
    164.   if ((d)->type->valDestructor) \
    165.       (d)->type->valDestructor((d)->privdata, (entry)->v.val)
    166. // 设置给定字典节点的值
    167. #define dictSetVal(d, entry, _val_) do { \
    168.   if ((d)->type->valDup) \
    169.       entry->v.val = (d)->type->valDup((d)->privdata, _val_); \
    170.   else \
    171.       entry->v.val = (_val_); \
    172. } while(0)
    173. // 将一个有符号整数设为节点的值
    174. #define dictSetSignedIntegerVal(entry, _val_) \
    175.   do { entry->v.s64 = _val_; } while(0)
    176. // 将一个无符号整数设为节点的值
    177. #define dictSetUnsignedIntegerVal(entry, _val_) \
    178.   do { entry->v.u64 = _val_; } while(0)
    179. // 释放给定字典节点的键
    180. #define dictFreeKey(d, entry) \
    181.   if ((d)->type->keyDestructor) \
    182.       (d)->type->keyDestructor((d)->privdata, (entry)->key)
    183. // 设置给定字典节点的键
    184. #define dictSetKey(d, entry, _key_) do { \
    185.   if ((d)->type->keyDup) \
    186.       entry->key = (d)->type->keyDup((d)->privdata, _key_); \
    187.   else \
    188.       entry->key = (_key_); \
    189. } while(0)
    190. // 比对两个键
    191. #define dictCompareKeys(d, key1, key2) \
    192.   (((d)->type->keyCompare) ? \
    193.       (d)->type->keyCompare((d)->privdata, key1, key2) : \
    194.       (key1) == (key2))
    195. // 计算给定键的哈希值
    196. #define dictHashKey(d, key) (d)->type->hashFunction(key)
    197. // 返回获取给定节点的键
    198. #define dictGetKey(he) ((he)->key)
    199. // 返回获取给定节点的值
    200. #define dictGetVal(he) ((he)->v.val)
    201. // 返回获取给定节点的有符号整数值
    202. #define dictGetSignedIntegerVal(he) ((he)->v.s64)
    203. // 返回给定节点的无符号整数值
    204. #define dictGetUnsignedIntegerVal(he) ((he)->v.u64)
    205. // 返回给定字典的大小
    206. #define dictSlots(d) ((d)->ht[0].size+(d)->ht[1].size)
    207. // 返回字典的已有节点数量
    208. #define dictSize(d) ((d)->ht[0].used+(d)->ht[1].used)
    209. // 查看字典是否正在 rehash
    210. #define dictIsRehashing(ht) ((ht)->rehashidx != -1)
    211. /* API */
    212. dict *dictCreate(dictType *type, void *privDataPtr);
    213. int dictExpand(dict *d, unsigned long size);
    214. int dictAdd(dict *d, void *key, void *val);
    215. dictEntry *dictAddRaw(dict *d, void *key);
    216. int dictReplace(dict *d, void *key, void *val);
    217. dictEntry *dictReplaceRaw(dict *d, void *key);
    218. int dictDelete(dict *d, const void *key);
    219. int dictDeleteNoFree(dict *d, const void *key);
    220. void dictRelease(dict *d);
    221. dictEntry * dictFind(dict *d, const void *key);
    222. void *dictFetchValue(dict *d, const void *key);
    223. int dictResize(dict *d);
    224. dictIterator *dictGetIterator(dict *d);
    225. dictIterator *dictGetSafeIterator(dict *d);
    226. dictEntry *dictNext(dictIterator *iter);
    227. void dictReleaseIterator(dictIterator *iter);
    228. dictEntry *dictGetRandomKey(dict *d);
    229. int dictGetRandomKeys(dict *d, dictEntry **des, int count);
    230. void dictPrintStats(dict *d);
    231. unsigned int dictGenHashFunction(const void *key, int len);
    232. unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len);
    233. void dictEmpty(dict *d, void(callback)(void*));
    234. void dictEnableResize(void);
    235. void dictDisableResize(void);
    236. int dictRehash(dict *d, int n);
    237. int dictRehashMilliseconds(dict *d, int ms);
    238. void dictSetHashFunctionSeed(unsigned int initval);
    239. unsigned int dictGetHashFunctionSeed(void);
    240. unsigned long dictScan(dict *d, unsigned long v, dictScanFunction *fn, void *privdata);
    241. /* Hash table types */
    242. extern dictType dictTypeHeapStringCopyKey;
    243. extern dictType dictTypeHeapStrings;
    244. extern dictType dictTypeHeapStringCopyKeyValue;
    245. #endif /* __DICT_H */
    1. /* Hash Tables Implementation.
    2. *
    3. * This file implements in memory hash tables with insert/del/replace/find/
    4. * get-random-element operations. Hash tables will auto resize if needed
    5. * tables of power of two in size are used, collisions are handled by
    6. * chaining. See the source code for more information... :)
    7. *
    8. * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez at gmail dot com>
    9. * All rights reserved.
    10. *
    11. * Redistribution and use in source and binary forms, with or without
    12. * modification, are permitted provided that the following conditions are met:
    13. *
    14. *   * Redistributions of source code must retain the above copyright notice,
    15. *     this list of conditions and the following disclaimer.
    16. *   * Redistributions in binary form must reproduce the above copyright
    17. *     notice, this list of conditions and the following disclaimer in the
    18. *     documentation and/or other materials provided with the distribution.
    19. *   * Neither the name of Redis nor the names of its contributors may be used
    20. *     to endorse or promote products derived from this software without
    21. *     specific prior written permission.
    22. *
    23. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    24. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    27. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    28. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    29. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    30. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    31. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    32. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    33. * POSSIBILITY OF SUCH DAMAGE.
    34. */
    35. #include "fmacros.h"
    36. #include <stdio.h>
    37. #include <stdlib.h>
    38. #include <string.h>
    39. #include <stdarg.h>
    40. #include <limits.h>
    41. #include <sys/time.h>
    42. #include <ctype.h>
    43. #include "dict.h"
    44. #include "zmalloc.h"
    45. #include "redisassert.h"
    46. /* Using dictEnableResize() / dictDisableResize() we make possible to
    47. * enable/disable resizing of the hash table as needed. This is very important
    48. * for Redis, as we use copy-on-write and don't want to move too much memory
    49. * around when there is a child performing saving operations.
    50. *
    51. * 通过 dictEnableResize() 和 dictDisableResize() 两个函数，
    52. * 程序可以手动地允许或阻止哈希表进行 rehash ，
    53. * 这在 Redis 使用子进程进行保存操作时，可以有效地利用 copy-on-write 机制。
    54. *
    55. * Note that even when dict_can_resize is set to 0, not all resizes are
    56. * prevented: a hash table is still allowed to grow if the ratio between
    57. * the number of elements and the buckets > dict_force_resize_ratio.
    58. *
    59. * 需要注意的是，并非所有 rehash 都会被 dictDisableResize 阻止：
    60. * 如果已使用节点的数量和字典大小之间的比率，
    61. * 大于字典强制 rehash 比率 dict_force_resize_ratio ，
    62. * 那么 rehash 仍然会（强制）进行。
    63. */
    64. // 指示字典是否启用 rehash 的标识
    65. static int dict_can_resize = 1;
    66. // 强制 rehash 的比率
    67. static unsigned int dict_force_resize_ratio = 5;
    68. /* -------------------------- private prototypes ---------------------------- */
    69. static int _dictExpandIfNeeded(dict *ht);
    70. static unsigned long _dictNextPower(unsigned long size);
    71. static int _dictKeyIndex(dict *ht, const void *key);
    72. static int _dictInit(dict *ht, dictType *type, void *privDataPtr);
    73. /* -------------------------- hash functions -------------------------------- */
    74. /* Thomas Wang's 32 bit Mix Function */
    75. unsigned int dictIntHashFunction(unsigned int key)
    76. {
    77.   key += ~(key << 15);
    78.   key ^=  (key >> 10);
    79.   key +=  (key << 3);
    80.   key ^=  (key >> 6);
    81.   key += ~(key << 11);
    82.   key ^=  (key >> 16);
    83.   return key;
    84. }
    85. /* Identity hash function for integer keys */
    86. unsigned int dictIdentityHashFunction(unsigned int key)
    87. {
    88.   return key;
    89. }
    90. static uint32_t dict_hash_function_seed = 5381;
    91. void dictSetHashFunctionSeed(uint32_t seed) {
    92.   dict_hash_function_seed = seed;
    93. }
    94. uint32_t dictGetHashFunctionSeed(void) {
    95.   return dict_hash_function_seed;
    96. }
    97. /* MurmurHash2, by Austin Appleby
    98. * Note - This code makes a few assumptions about how your machine behaves -
    99. * 1. We can read a 4-byte value from any address without crashing
    100. * 2. sizeof(int) == 4
    101. *
    102. * And it has a few limitations -
    103. *
    104. * 1. It will not work incrementally.
    105. * 2. It will not produce the same results on little-endian and big-endian
    106. *    machines.
    107. */
    108. unsigned int dictGenHashFunction(const void *key, int len) {
    109.   /* 'm' and 'r' are mixing constants generated offline.
    110.    They're not really 'magic', they just happen to work well.  */
    111.   uint32_t seed = dict_hash_function_seed;
    112.   const uint32_t m = 0x5bd1e995;
    113.   const int r = 24;
    114.   /* Initialize the hash to a 'random' value */
    115.   uint32_t h = seed ^ len;
    116.   /* Mix 4 bytes at a time into the hash */
    117.   const unsigned char *data = (const unsigned char *)key;
    118.   while(len >= 4) {
    119.       uint32_t k = *(uint32_t*)data;
    120.       k *= m;
    121.       k ^= k >> r;
    122.       k *= m;
    123.       h *= m;
    124.       h ^= k;
    125.       data += 4;
    126.       len -= 4;
    127.   }
    128.   /* Handle the last few bytes of the input array  */
    129.   switch(len) {
    130.   case 3: h ^= data[2] << 16;
    131.   case 2: h ^= data[1] << 8;
    132.   case 1: h ^= data[0]; h *= m;
    133.   };
    134.   /* Do a few final mixes of the hash to ensure the last few
    135.    * bytes are well-incorporated. */
    136.   h ^= h >> 13;
    137.   h *= m;
    138.   h ^= h >> 15;
    139.   return (unsigned int)h;
    140. }
    141. /* And a case insensitive hash function (based on djb hash) */
    142. unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) {
    143.   unsigned int hash = (unsigned int)dict_hash_function_seed;
    144.   while (len--)
    145.       hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */
    146.   return hash;
    147. }
    148. /* ----------------------------- API implementation ------------------------- */
    149. /* Reset a hash table already initialized with ht_init().
    150. * NOTE: This function should only be called by ht_destroy(). */
    151. /*
    152. * 重置（或初始化）给定哈希表的各项属性值
    153. *
    154. * p.s. 上面的英文注释已经过期
    155. *
    156. * T = O(1)
    157. */
    158. static void _dictReset(dictht *ht)
    159. {
    160.   ht->table = NULL;
    161.   ht->size = 0;
    162.   ht->sizemask = 0;
    163.   ht->used = 0;
    164. }
    165. /* Create a new hash table */
    166. /*
    167. * 创建一个新的字典
    168. *
    169. * T = O(1)
    170. */
    171. dict *dictCreate(dictType *type,
    172.       void *privDataPtr)
    173. {
    174.   dict *d = zmalloc(sizeof(*d));
    175.   _dictInit(d,type,privDataPtr);
    176.   return d;
    177. }
    178. /* Initialize the hash table */
    179. /*
    180. * 初始化哈希表
    181. *
    182. * T = O(1)
    183. */
    184. int _dictInit(dict *d, dictType *type,
    185.       void *privDataPtr)
    186. {
    187.   // 初始化两个哈希表的各项属性值
    188.   // 但暂时还不分配内存给哈希表数组
    189.   _dictReset(&d->ht[0]);
    190.   _dictReset(&d->ht[1]);
    191.   // 设置类型特定函数
    192.   d->type = type;
    193.   // 设置私有数据
    194.   d->privdata = privDataPtr;
    195.   // 设置哈希表 rehash 状态
    196.   d->rehashidx = -1;
    197.   // 设置字典的安全迭代器数量
    198.   d->iterators = 0;
    199.   return DICT_OK;
    200. }
    201. /* Resize the table to the minimal size that contains all the elements,
    202. * but with the invariant of a USED/BUCKETS ratio near to <= 1 */
    203. /*
    204. * 缩小给定字典
    205. * 让它的已用节点数和字典大小之间的比率接近 1:1
    206. *
    207. * 返回 DICT_ERR 表示字典已经在 rehash ，或者 dict_can_resize 为假。
    208. *
    209. * 成功创建体积更小的 ht[1] ，可以开始 resize 时，返回 DICT_OK。
    210. *
    211. * T = O(N)
    212. */
    213. int dictResize(dict *d)
    214. {
    215.   int minimal;
    216.   // 不能在关闭 rehash 或者正在 rehash 的时候调用
    217.   if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
    218.   // 计算让比率接近 1：1 所需要的最少节点数量
    219.   minimal = d->ht[0].used;
    220.   if (minimal < DICT_HT_INITIAL_SIZE)
    221.       minimal = DICT_HT_INITIAL_SIZE;
    222.   // 调整字典的大小
    223.   // T = O(N)
    224.   return dictExpand(d, minimal);
    225. }
    226. /* Expand or create the hash table */
    227. /*
    228. * 创建一个新的哈希表，并根据字典的情况，选择以下其中一个动作来进行：
    229. *
    230. * 1) 如果字典的 0 号哈希表为空，那么将新哈希表设置为 0 号哈希表
    231. * 2) 如果字典的 0 号哈希表非空，那么将新哈希表设置为 1 号哈希表，
    232. *    并打开字典的 rehash 标识，使得程序可以开始对字典进行 rehash
    233. *
    234. * size 参数不够大，或者 rehash 已经在进行时，返回 DICT_ERR 。
    235. *
    236. * 成功创建 0 号哈希表，或者 1 号哈希表时，返回 DICT_OK 。
    237. *
    238. * T = O(N)
    239. */
    240. int dictExpand(dict *d, unsigned long size)
    241. {
    242.   // 新哈希表
    243.   dictht n; /* the new hash table */
    244.   // 根据 size 参数，计算哈希表的大小
    245.   // T = O(1)
    246.   unsigned long realsize = _dictNextPower(size);
    247.   /* the size is invalid if it is smaller than the number of
    248.    * elements already inside the hash table */
    249.   // 不能在字典正在 rehash 时进行
    250.   // size 的值也不能小于 0 号哈希表的当前已使用节点
    251.   if (dictIsRehashing(d) || d->ht[0].used > size)
    252.       return DICT_ERR;
    253.   /* Allocate the new hash table and initialize all pointers to NULL */
    254.   // 为哈希表分配空间，并将所有指针指向 NULL
    255.   n.size = realsize;
    256.   n.sizemask = realsize-1;
    257.   // T = O(N)
    258.   n.table = zcalloc(realsize*sizeof(dictEntry*));
    259.   n.used = 0;
    260.   /* Is this the first initialization? If so it's not really a rehashing
    261.    * we just set the first hash table so that it can accept keys. */
    262.   // 如果 0 号哈希表为空，那么这是一次初始化：
    263.   // 程序将新哈希表赋给 0 号哈希表的指针，然后字典就可以开始处理键值对了。
    264.   if (d->ht[0].table == NULL) {
    265.       d->ht[0] = n;
    266.       return DICT_OK;
    267.   }
    268.   /* Prepare a second hash table for incremental rehashing */
    269.   // 如果 0 号哈希表非空，那么这是一次 rehash ：
    270.   // 程序将新哈希表设置为 1 号哈希表，
    271.   // 并将字典的 rehash 标识打开，让程序可以开始对字典进行 rehash
    272.   d->ht[1] = n;
    273.   d->rehashidx = 0;
    274.   return DICT_OK;
    275.   /* 顺带一提，上面的代码可以重构成以下形式：
    277.   if (d->ht[0].table == NULL) {
    278.       // 初始化
    279.       d->ht[0] = n;
    280.   } else {
    281.       // rehash 
    282.       d->ht[1] = n;
    283.       d->rehashidx = 0;
    284.   }
    285.   return DICT_OK;
    286.   */
    287. }
    288. /* Performs N steps of incremental rehashing. Returns 1 if there are still
    289. * keys to move from the old to the new hash table, otherwise 0 is returned.
    290. *
    291. * 执行 N 步渐进式 rehash 。
    292. *
    293. * 返回 1 表示仍有键需要从 0 号哈希表移动到 1 号哈希表，
    294. * 返回 0 则表示所有键都已经迁移完毕。
    295. *
    296. * Note that a rehashing step consists in moving a bucket (that may have more
    297. * than one key as we use chaining) from the old to the new hash table.
    298. *
    299. * 注意，每步 rehash 都是以一个哈希表索引（桶）作为单位的，
    300. * 一个桶里可能会有多个节点，
    301. * 被 rehash 的桶里的所有节点都会被移动到新哈希表。
    302. *
    303. * T = O(N)
    304. */
    305. int dictRehash(dict *d, int n) {
    306.   // 只可以在 rehash 进行中时执行
    307.   if (!dictIsRehashing(d)) return 0;
    308.   // 进行 N 步迁移
    309.   // T = O(N)
    310.   while(n--) {
    311.       dictEntry *de, *nextde;
    312.       /* Check if we already rehashed the whole table... */
    313.       // 如果 0 号哈希表为空，那么表示 rehash 执行完毕
    314.       // T = O(1)
    315.       if (d->ht[0].used == 0) {
    316.           // 释放 0 号哈希表
    317.           zfree(d->ht[0].table);
    318.           // 将原来的 1 号哈希表设置为新的 0 号哈希表
    319.           d->ht[0] = d->ht[1];
    320.           // 重置旧的 1 号哈希表
    321.           _dictReset(&d->ht[1]);
    322.           // 关闭 rehash 标识
    323.           d->rehashidx = -1;
    324.           // 返回 0 ，向调用者表示 rehash 已经完成
    325.           return 0;
    326.       }
    327.       /* Note that rehashidx can't overflow as we are sure there are more
    328.        * elements because ht[0].used != 0 */
    329.       // 确保 rehashidx 没有越界
    330.       assert(d->ht[0].size > (unsigned)d->rehashidx);
    331.       // 略过数组中为空的索引，找到下一个非空索引
    332.       while(d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++;
    333.       // 指向该索引的链表表头节点
    334.       de = d->ht[0].table[d->rehashidx];
    335.       /* Move all the keys in this bucket from the old to the new hash HT */
    336.       // 将链表中的所有节点迁移到新哈希表
    337.       // T = O(1)
    338.       while(de) {
    339.           unsigned int h;
    340.           // 保存下个节点的指针
    341.           nextde = de->next;
    342.           /* Get the index in the new hash table */
    343.           // 计算新哈希表的哈希值，以及节点插入的索引位置
    344.           h = dictHashKey(d, de->key) & d->ht[1].sizemask;
    345.           // 插入节点到新哈希表
    346.           de->next = d->ht[1].table[h];
    347.           d->ht[1].table[h] = de;
    348.           // 更新计数器
    349.           d->ht[0].used--;
    350.           d->ht[1].used++;
    351.           // 继续处理下个节点
    352.           de = nextde;
    353.       }
    354.       // 将刚迁移完的哈希表索引的指针设为空
    355.       d->ht[0].table[d->rehashidx] = NULL;
    356.       // 更新 rehash 索引
    357.       d->rehashidx++;
    358.   }
    359.   return 1;
    360. }
    361. /*
    362. * 返回以毫秒为单位的 UNIX 时间戳
    363. *
    364. * T = O(1)
    365. */
    366. long long timeInMilliseconds(void) {
    367.   struct timeval tv;
    368.   gettimeofday(&tv,NULL);
    369.   return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000);
    370. }
    371. /* Rehash for an amount of time between ms milliseconds and ms+1 milliseconds */
    372. /*
    373. * 在给定毫秒数内，以 100 步为单位，对字典进行 rehash 。
    374. *
    375. * T = O(N)
    376. */
    377. int dictRehashMilliseconds(dict *d, int ms) {
    378.   // 记录开始时间
    379.   long long start = timeInMilliseconds();
    380.   int rehashes = 0;
    381.   while(dictRehash(d,100)) {
    382.       rehashes += 100;
    383.       // 如果时间已过，跳出
    384.       if (timeInMilliseconds()-start > ms) break;
    385.   }
    386.   return rehashes;
    387. }
    388. /* This function performs just a step of rehashing, and only if there are
    389. * no safe iterators bound to our hash table. When we have iterators in the
    390. * middle of a rehashing we can't mess with the two hash tables otherwise
    391. * some element can be missed or duplicated.
    392. *
    393. * 在字典不存在安全迭代器的情况下，对字典进行单步 rehash 。
    394. *
    395. * 字典有安全迭代器的情况下不能进行 rehash ，
    396. * 因为两种不同的迭代和修改操作可能会弄乱字典。
    397. *
    398. * This function is called by common lookup or update operations in the
    399. * dictionary so that the hash table automatically migrates from H1 to H2
    400. * while it is actively used. 
    401. *
    402. * 这个函数被多个通用的查找、更新操作调用，
    403. * 它可以让字典在被使用的同时进行 rehash 。
    404. *
    405. * T = O(1)
    406. */
    407. static void _dictRehashStep(dict *d) {
    408.   if (d->iterators == 0) dictRehash(d,1);
    409. }
    410. /* Add an element to the target hash table */
    411. /*
    412. * 尝试将给定键值对添加到字典中
    413. *
    414. * 只有给定键 key 不存在于字典时，添加操作才会成功
    415. *
    416. * 添加成功返回 DICT_OK ，失败返回 DICT_ERR
    417. *
    418. * 最坏 T = O(N) ，平滩 O(1) 
    419. */
    420. int dictAdd(dict *d, void *key, void *val)
    421. {
    422.   // 尝试添加键到字典，并返回包含了这个键的新哈希节点
    423.   // T = O(N)
    424.   dictEntry *entry = dictAddRaw(d,key);
    425.   // 键已存在，添加失败
    426.   if (!entry) return DICT_ERR;
    427.   // 键不存在，设置节点的值
    428.   // T = O(1)
    429.   dictSetVal(d, entry, val);
    430.   // 添加成功
    431.   return DICT_OK;
    432. }
    433. /* Low level add. This function adds the entry but instead of setting
    434. * a value returns the dictEntry structure to the user, that will make
    435. * sure to fill the value field as he wishes.
    436. *
    437. * This function is also directly exposed to user API to be called
    438. * mainly in order to store non-pointers inside the hash value, example:
    439. *
    440. * entry = dictAddRaw(dict,mykey);
    441. * if (entry != NULL) dictSetSignedIntegerVal(entry,1000);
    442. *
    443. * Return values:
    444. *
    445. * If key already exists NULL is returned.
    446. * If key was added, the hash entry is returned to be manipulated by the caller.
    447. */
    448. /*
    449. * 尝试将键插入到字典中
    450. *
    451. * 如果键已经在字典存在，那么返回 NULL
    452. *
    453. * 如果键不存在，那么程序创建新的哈希节点，
    454. * 将节点和键关联，并插入到字典，然后返回节点本身。
    455. *
    456. * T = O(N)
    457. */
    458. dictEntry *dictAddRaw(dict *d, void *key)
    459. {
    460.   int index;
    461.   dictEntry *entry;
    462.   dictht *ht;
    463.   // 如果条件允许的话，进行单步 rehash
    464.   // T = O(1)
    465.   if (dictIsRehashing(d)) _dictRehashStep(d);
    466.   /* Get the index of the new element, or -1 if
    467.    * the element already exists. */
    468.   // 计算键在哈希表中的索引值
    469.   // 如果值为 -1 ，那么表示键已经存在
    470.   // T = O(N)
    471.   if ((index = _dictKeyIndex(d, key)) == -1)
    472.       return NULL;
    473.   // T = O(1)
    474.   /* Allocate the memory and store the new entry */
    475.   // 如果字典正在 rehash ，那么将新键添加到 1 号哈希表
    476.   // 否则，将新键添加到 0 号哈希表
    477.   ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    478.   // 为新节点分配空间
    479.   entry = zmalloc(sizeof(*entry));
    480.   // 将新节点插入到链表表头
    481.   entry->next = ht->table[index];
    482.   ht->table[index] = entry;
    483.   // 更新哈希表已使用节点数量
    484.   ht->used++;
    485.   /* Set the hash entry fields. */
    486.   // 设置新节点的键
    487.   // T = O(1)
    488.   dictSetKey(d, entry, key);
    489.   return entry;
    490. }
    491. /* Add an element, discarding the old if the key already exists.
    492. *
    493. * 将给定的键值对添加到字典中，如果键已经存在，那么删除旧有的键值对。
    494. *
    495. * Return 1 if the key was added from scratch, 0 if there was already an
    496. * element with such key and dictReplace() just performed a value update
    497. * operation. 
    498. *
    499. * 如果键值对为全新添加，那么返回 1 。
    500. * 如果键值对是通过对原有的键值对更新得来的，那么返回 0 。
    501. *
    502. * T = O(N)
    503. */
    504. int dictReplace(dict *d, void *key, void *val)
    505. {
    506.   dictEntry *entry, auxentry;
    507.   /* Try to add the element. If the key
    508.    * does not exists dictAdd will suceed. */
    509.   // 尝试直接将键值对添加到字典
    510.   // 如果键 key 不存在的话，添加会成功
    511.   // T = O(N)
    512.   if (dictAdd(d, key, val) == DICT_OK)
    513.       return 1;
    514.   /* It already exists, get the entry */
    515.   // 运行到这里，说明键 key 已经存在，那么找出包含这个 key 的节点
    516.   // T = O(1)
    517.   entry = dictFind(d, key);
    518.   /* Set the new value and free the old one. Note that it is important
    519.    * to do that in this order, as the value may just be exactly the same
    520.    * as the previous one. In this context, think to reference counting,
    521.    * you want to increment (set), and then decrement (free), and not the
    522.    * reverse. */
    523.   // 先保存原有的值的指针
    524.   auxentry = *entry;
    525.   // 然后设置新的值
    526.   // T = O(1)
    527.   dictSetVal(d, entry, val);
    528.   // 然后释放旧值
    529.   // T = O(1)
    530.   dictFreeVal(d, &auxentry);
    531.   return 0;
    532. }
    533. /* dictReplaceRaw() is simply a version of dictAddRaw() that always
    534. * returns the hash entry of the specified key, even if the key already
    535. * exists and can't be added (in that case the entry of the already
    536. * existing key is returned.)
    537. *
    538. * See dictAddRaw() for more information. */
    539. /*
    540. * dictAddRaw() 根据给定 key 释放存在，执行以下动作：
    541. *
    542. * 1) key 已经存在，返回包含该 key 的字典节点
    543. * 2) key 不存在，那么将 key 添加到字典
    544. *
    545. * 不论发生以上的哪一种情况，
    546. * dictAddRaw() 都总是返回包含给定 key 的字典节点。
    547. *
    548. * T = O(N)
    549. */
    550. dictEntry *dictReplaceRaw(dict *d, void *key) {
    552.   // 使用 key 在字典中查找节点
    553.   // T = O(1)
    554.   dictEntry *entry = dictFind(d,key);
    555.   // 如果节点找到了直接返回节点，否则添加并返回一个新节点
    556.   // T = O(N)
    557.   return entry ? entry : dictAddRaw(d,key);
    558. }
    559. /* Search and remove an element */
    560. /*
    561. * 查找并删除包含给定键的节点
    562. *
    563. * 参数 nofree 决定是否调用键和值的释放函数
    564. * 0 表示调用，1 表示不调用
    565. *
    566. * 找到并成功删除返回 DICT_OK ，没找到则返回 DICT_ERR
    567. *
    568. * T = O(1)
    569. */
    570. static int dictGenericDelete(dict *d, const void *key, int nofree)
    571. {
    572.   unsigned int h, idx;
    573.   dictEntry *he, *prevHe;
    574.   int table;
    575.   // 字典（的哈希表）为空
    576.   if (d->ht[0].size == 0) return DICT_ERR; /* d->ht[0].table is NULL */
    577.   // 进行单步 rehash ，T = O(1)
    578.   if (dictIsRehashing(d)) _dictRehashStep(d);
    579.   // 计算哈希值
    580.   h = dictHashKey(d, key);
    581.   // 遍历哈希表
    582.   // T = O(1)
    583.   for (table = 0; table <= 1; table++) {
    584.       // 计算索引值 
    585.       idx = h & d->ht[table].sizemask;
    586.       // 指向该索引上的链表
    587.       he = d->ht[table].table[idx];
    588.       prevHe = NULL;
    589.       // 遍历链表上的所有节点
    590.       // T = O(1)
    591.       while(he) {
    593.           if (dictCompareKeys(d, key, he->key)) {
    594.               // 超找目标节点
    595.               /* Unlink the element from the list */
    596.               // 从链表中删除
    597.               if (prevHe)
    598.                   prevHe->next = he->next;
    599.               else
    600.                   d->ht[table].table[idx] = he->next;
    601.               // 释放调用键和值的释放函数？
    602.               if (!nofree) {
    603.                   dictFreeKey(d, he);
    604.                   dictFreeVal(d, he);
    605.               }
    607.               // 释放节点本身
    608.               zfree(he);
    609.               // 更新已使用节点数量
    610.               d->ht[table].used--;
    611.               // 返回已找到信号
    612.               return DICT_OK;
    613.           }
    614.           prevHe = he;
    615.           he = he->next;
    616.       }
    617.       // 如果执行到这里，说明在 0 号哈希表中找不到给定键
    618.       // 那么根据字典是否正在进行 rehash ，决定要不要查找 1 号哈希表
    619.       if (!dictIsRehashing(d)) break;
    620.   }
    621.   // 没找到
    622.   return DICT_ERR; /* not found */
    623. }
    624. /*
    625. * 从字典中删除包含给定键的节点
    626. * 
    627. * 并且调用键值的释放函数来删除键值
    628. *
    629. * 找到并成功删除返回 DICT_OK ，没找到则返回 DICT_ERR
    630. * T = O(1)
    631. */
    632. int dictDelete(dict *ht, const void *key) {
    633.   return dictGenericDelete(ht,key,0);
    634. }
    635. /*
    636. * 从字典中删除包含给定键的节点
    637. * 
    638. * 但不调用键值的释放函数来删除键值
    639. *
    640. * 找到并成功删除返回 DICT_OK ，没找到则返回 DICT_ERR
    641. * T = O(1)
    642. */
    643. int dictDeleteNoFree(dict *ht, const void *key) {
    644.   return dictGenericDelete(ht,key,1);
    645. }
    646. /* Destroy an entire dictionary */
    647. /*
    648. * 删除哈希表上的所有节点，并重置哈希表的各项属性
    649. *
    650. * T = O(N)
    651. */
    652. int _dictClear(dict *d, dictht *ht, void(callback)(void *)) {
    653.   unsigned long i;
    654.   /* Free all the elements */
    655.   // 遍历整个哈希表
    656.   // T = O(N)
    657.   for (i = 0; i < ht->size && ht->used > 0; i++) {
    658.       dictEntry *he, *nextHe;
    659.       if (callback && (i & 65535) == 0) callback(d->privdata);
    660.       // 跳过空索引
    661.       if ((he = ht->table[i]) == NULL) continue;
    662.       // 遍历整个链表
    663.       // T = O(1)
    664.       while(he) {
    665.           nextHe = he->next;
    666.           // 删除键
    667.           dictFreeKey(d, he);
    668.           // 删除值
    669.           dictFreeVal(d, he);
    670.           // 释放节点
    671.           zfree(he);
    672.           // 更新已使用节点计数
    673.           ht->used--;
    674.           // 处理下个节点
    675.           he = nextHe;
    676.       }
    677.   }
    678.   /* Free the table and the allocated cache structure */
    679.   // 释放哈希表结构
    680.   zfree(ht->table);
    681.   /* Re-initialize the table */
    682.   // 重置哈希表属性
    683.   _dictReset(ht);
    684.   return DICT_OK; /* never fails */
    685. }
    686. /* Clear & Release the hash table */
    687. /*
    688. * 删除并释放整个字典
    689. *
    690. * T = O(N)
    691. */
    692. void dictRelease(dict *d)
    693. {
    694.   // 删除并清空两个哈希表
    695.   _dictClear(d,&d->ht[0],NULL);
    696.   _dictClear(d,&d->ht[1],NULL);
    697.   // 释放节点结构
    698.   zfree(d);
    699. }
    700. /*
    701. * 返回字典中包含键 key 的节点
    702. *
    703. * 找到返回节点，找不到返回 NULL
    704. *
    705. * T = O(1)
    706. */
    707. dictEntry *dictFind(dict *d, const void *key)
    708. {
    709.   dictEntry *he;
    710.   unsigned int h, idx, table;
    711.   // 字典（的哈希表）为空
    712.   if (d->ht[0].size == 0) return NULL; /* We don't have a table at all */
    713.   // 如果条件允许的话，进行单步 rehash
    714.   if (dictIsRehashing(d)) _dictRehashStep(d);
    715.   // 计算键的哈希值
    716.   h = dictHashKey(d, key);
    717.   // 在字典的哈希表中查找这个键
    718.   // T = O(1)
    719.   for (table = 0; table <= 1; table++) {
    720.       // 计算索引值
    721.       idx = h & d->ht[table].sizemask;
    722.       // 遍历给定索引上的链表的所有节点，查找 key
    723.       he = d->ht[table].table[idx];
    724.       // T = O(1)
    725.       while(he) {
    726.           if (dictCompareKeys(d, key, he->key))
    727.               return he;
    728.           he = he->next;
    729.       }
    730.       // 如果程序遍历完 0 号哈希表，仍然没找到指定的键的节点
    731.       // 那么程序会检查字典是否在进行 rehash ，
    732.       // 然后才决定是直接返回 NULL ，还是继续查找 1 号哈希表
    733.       if (!dictIsRehashing(d)) return NULL;
    734.   }
    735.   // 进行到这里时，说明两个哈希表都没找到
    736.   return NULL;
    737. }
    738. /*
    739. * 获取包含给定键的节点的值
    740. *
    741. * 如果节点不为空，返回节点的值
    742. * 否则返回 NULL
    743. *
    744. * T = O(1)
    745. */
    746. void *dictFetchValue(dict *d, const void *key) {
    747.   dictEntry *he;
    748.   // T = O(1)
    749.   he = dictFind(d,key);
    750.   return he ? dictGetVal(he) : NULL;
    751. }
    752. /* A fingerprint is a 64 bit number that represents the state of the dictionary
    753. * at a given time, it's just a few dict properties xored together.
    754. * When an unsafe iterator is initialized, we get the dict fingerprint, and check
    755. * the fingerprint again when the iterator is released.
    756. * If the two fingerprints are different it means that the user of the iterator
    757. * performed forbidden operations against the dictionary while iterating. */
    758. long long dictFingerprint(dict *d) {
    759.   long long integers[6], hash = 0;
    760.   int j;
    761.   integers[0] = (long) d->ht[0].table;
    762.   integers[1] = d->ht[0].size;
    763.   integers[2] = d->ht[0].used;
    764.   integers[3] = (long) d->ht[1].table;
    765.   integers[4] = d->ht[1].size;
    766.   integers[5] = d->ht[1].used;
    767.   /* We hash N integers by summing every successive integer with the integer
    768.    * hashing of the previous sum. Basically:
    769.    *
    770.    * Result = hash(hash(hash(int1)+int2)+int3) ...
    771.    *
    772.    * This way the same set of integers in a different order will (likely) hash
    773.    * to a different number. */
    774.   for (j = 0; j < 6; j++) {
    775.       hash += integers[j];
    776.       /* For the hashing step we use Tomas Wang's 64 bit integer hash. */
    777.       hash = (~hash) + (hash << 21); // hash = (hash << 21) - hash - 1;
    778.       hash = hash ^ (hash >> 24);
    779.       hash = (hash + (hash << 3)) + (hash << 8); // hash * 265
    780.       hash = hash ^ (hash >> 14);
    781.       hash = (hash + (hash << 2)) + (hash << 4); // hash * 21
    782.       hash = hash ^ (hash >> 28);
    783.       hash = hash + (hash << 31);
    784.   }
    785.   return hash;
    786. }
    787. /*
    788. * 创建并返回给定字典的不安全迭代器
    789. *
    790. * T = O(1)
    791. */
    792. dictIterator *dictGetIterator(dict *d)
    793. {
    794.   dictIterator *iter = zmalloc(sizeof(*iter));
    795.   iter->d = d;
    796.   iter->table = 0;
    797.   iter->index = -1;
    798.   iter->safe = 0;
    799.   iter->entry = NULL;
    800.   iter->nextEntry = NULL;
    801.   return iter;
    802. }
    803. /*
    804. * 创建并返回给定节点的安全迭代器
    805. *
    806. * T = O(1)
    807. */
    808. dictIterator *dictGetSafeIterator(dict *d) {
    809.   dictIterator *i = dictGetIterator(d);
    810.   // 设置安全迭代器标识
    811.   i->safe = 1;
    812.   return i;
    813. }
    814. /*
    815. * 返回迭代器指向的当前节点
    816. *
    817. * 字典迭代完毕时，返回 NULL
    818. *
    819. * T = O(1)
    820. */
    821. dictEntry *dictNext(dictIterator *iter)
    822. {
    823.   while (1) {
    824.       // 进入这个循环有两种可能：
    825.       // 1) 这是迭代器第一次运行
    826.       // 2) 当前索引链表中的节点已经迭代完（NULL 为链表的表尾）
    827.       if (iter->entry == NULL) {
    828.           // 指向被迭代的哈希表
    829.           dictht *ht = &iter->d->ht[iter->table];
    830.           // 初次迭代时执行
    831.           if (iter->index == -1 && iter->table == 0) {
    832.               // 如果是安全迭代器，那么更新安全迭代器计数器
    833.               if (iter->safe)
    834.                   iter->d->iterators++;
    835.               // 如果是不安全迭代器，那么计算指纹
    836.               else
    837.                   iter->fingerprint = dictFingerprint(iter->d);
    838.           }
    839.           // 更新索引
    840.           iter->index++;
    841.           // 如果迭代器的当前索引大于当前被迭代的哈希表的大小
    842.           // 那么说明这个哈希表已经迭代完毕
    843.           if (iter->index >= (signed) ht->size) {
    844.               // 如果正在 rehash 的话，那么说明 1 号哈希表也正在使用中
    845.               // 那么继续对 1 号哈希表进行迭代
    846.               if (dictIsRehashing(iter->d) && iter->table == 0) {
    847.                   iter->table++;
    848.                   iter->index = 0;
    849.                   ht = &iter->d->ht[1];
    850.               // 如果没有 rehash ，那么说明迭代已经完成
    851.               } else {
    852.                   break;
    853.               }
    854.           }
    855.           // 如果进行到这里，说明这个哈希表并未迭代完
    856.           // 更新节点指针，指向下个索引链表的表头节点
    857.           iter->entry = ht->table[iter->index];
    858.       } else {
    859.           // 执行到这里，说明程序正在迭代某个链表
    860.           // 将节点指针指向链表的下个节点
    861.           iter->entry = iter->nextEntry;
    862.       }
    863.       // 如果当前节点不为空，那么也记录下该节点的下个节点
    864.       // 因为安全迭代器有可能会将迭代器返回的当前节点删除
    865.       if (iter->entry) {
    866.           /* We need to save the 'next' here, the iterator user
    867.            * may delete the entry we are returning. */
    868.           iter->nextEntry = iter->entry->next;
    869.           return iter->entry;
    870.       }
    871.   }
    872.   // 迭代完毕
    873.   return NULL;
    874. }
    875. /*
    876. * 释放给定字典迭代器
    877. *
    878. * T = O(1)
    879. */
    880. void dictReleaseIterator(dictIterator *iter)
    881. {
    882.   if (!(iter->index == -1 && iter->table == 0)) {
    883.       // 释放安全迭代器时，安全迭代器计数器减一
    884.       if (iter->safe)
    885.           iter->d->iterators--;
    886.       // 释放不安全迭代器时，验证指纹是否有变化
    887.       else
    888.           assert(iter->fingerprint == dictFingerprint(iter->d));
    889.   }
    890.   zfree(iter);
    891. }
    892. /* Return a random entry from the hash table. Useful to
    893. * implement randomized algorithms */
    894. /*
    895. * 随机返回字典中任意一个节点。
    896. *
    897. * 可用于实现随机化算法。
    898. *
    899. * 如果字典为空，返回 NULL 。
    900. *
    901. * T = O(N)
    902. */
    903. dictEntry *dictGetRandomKey(dict *d)
    904. {
    905.   dictEntry *he, *orighe;
    906.   unsigned int h;
    907.   int listlen, listele;
    908.   // 字典为空
    909.   if (dictSize(d) == 0) return NULL;
    910.   // 进行单步 rehash
    911.   if (dictIsRehashing(d)) _dictRehashStep(d);
    912.   // 如果正在 rehash ，那么将 1 号哈希表也作为随机查找的目标
    913.   if (dictIsRehashing(d)) {
    914.       // T = O(N)
    915.       do {
    916.           h = random() % (d->ht[0].size+d->ht[1].size);
    917.           he = (h >= d->ht[0].size) ? d->ht[1].table[h - d->ht[0].size] :
    918.                                     d->ht[0].table[h];
    919.       } while(he == NULL);
    920.   // 否则，只从 0 号哈希表中查找节点
    921.   } else {
    922.       // T = O(N)
    923.       do {
    924.           h = random() & d->ht[0].sizemask;
    925.           he = d->ht[0].table[h];
    926.       } while(he == NULL);
    927.   }
    928.   /* Now we found a non empty bucket, but it is a linked
    929.    * list and we need to get a random element from the list.
    930.    * The only sane way to do so is counting the elements and
    931.    * select a random index. */
    932.   // 目前 he 已经指向一个非空的节点链表
    933.   // 程序将从这个链表随机返回一个节点
    934.   listlen = 0;
    935.   orighe = he;
    936.   // 计算节点数量, T = O(1)
    937.   while(he) {
    938.       he = he->next;
    939.       listlen++;
    940.   }
    941.   // 取模，得出随机节点的索引
    942.   listele = random() % listlen;
    943.   he = orighe;
    944.   // 按索引查找节点
    945.   // T = O(1)
    946.   while(listele--) he = he->next;
    947.   // 返回随机节点
    948.   return he;
    949. }
    950. /* This is a version of dictGetRandomKey() that is modified in order to
    951. * return multiple entries by jumping at a random place of the hash table
    952. * and scanning linearly for entries.
    953. *
    954. * Returned pointers to hash table entries are stored into 'des' that
    955. * points to an array of dictEntry pointers. The array must have room for
    956. * at least 'count' elements, that is the argument we pass to the function
    957. * to tell how many random elements we need.
    958. *
    959. * The function returns the number of items stored into 'des', that may
    960. * be less than 'count' if the hash table has less than 'count' elements
    961. * inside.
    962. *
    963. * Note that this function is not suitable when you need a good distribution
    964. * of the returned items, but only when you need to "sample" a given number
    965. * of continuous elements to run some kind of algorithm or to produce
    966. * statistics. However the function is much faster than dictGetRandomKey()
    967. * at producing N elements, and the elements are guaranteed to be non
    968. * repeating. */
    969. int dictGetRandomKeys(dict *d, dictEntry **des, int count) {
    970.   int j; /* internal hash table id, 0 or 1. */
    971.   int stored = 0;
    972.   if (dictSize(d) < count) count = dictSize(d);
    973.   while(stored < count) {
    974.       for (j = 0; j < 2; j++) {
    975.           /* Pick a random point inside the hash table 0 or 1. */
    976.           unsigned int i = random() & d->ht[j].sizemask;
    977.           int size = d->ht[j].size;
    978.           /* Make sure to visit every bucket by iterating 'size' times. */
    979.           while(size--) {
    980.               dictEntry *he = d->ht[j].table[i];
    981.               while (he) {
    982.                   /* Collect all the elements of the buckets found non
    983.                    * empty while iterating. */
    984.                   *des = he;
    985.                   des++;
    986.                   he = he->next;
    987.                   stored++;
    988.                   if (stored == count) return stored;
    989.               }
    990.               i = (i+1) & d->ht[j].sizemask;
    991.           }
    992.           /* If there is only one table and we iterated it all, we should
    993.            * already have 'count' elements. Assert this condition. */
    994.           assert(dictIsRehashing(d) != 0);
    995.       }
    996.   }
    997.   return stored; /* Never reached. */
    998. }
    999. /* Function to reverse bits. Algorithm from:
    1000. * http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */
    1001. static unsigned long rev(unsigned long v) {
    1002.   unsigned long s = 8 * sizeof(v); // bit size; must be power of 2
    1003.   unsigned long mask = ~0;
    1004.   while ((s >>= 1) > 0) {
    1005.       mask ^= (mask << s);
    1006.       v = ((v >> s) & mask) | ((v << s) & ~mask);
    1007.   }
    1008.   return v;
    1009. }
    1010. /* dictScan() is used to iterate over the elements of a dictionary.
    1011. *
    1012. * dictScan() 函数用于迭代给定字典中的元素。
    1013. *
    1014. * Iterating works in the following way:
    1015. *
    1016. * 迭代按以下方式执行：
    1017. *
    1018. * 1) Initially you call the function using a cursor (v) value of 0.
    1019. *    一开始，你使用 0 作为游标来调用函数。
    1020. * 2) The function performs one step of the iteration, and returns the
    1021. *    new cursor value that you must use in the next call.
    1022. *    函数执行一步迭代操作，
    1023. *    并返回一个下次迭代时使用的新游标。
    1024. * 3) When the returned cursor is 0, the iteration is complete.
    1025. *    当函数返回的游标为 0 时，迭代完成。
    1026. *
    1027. * The function guarantees that all the elements that are present in the
    1028. * dictionary from the start to the end of the iteration are returned.
    1029. * However it is possible that some element is returned multiple time.
    1030. *
    1031. * 函数保证，在迭代从开始到结束期间，一直存在于字典的元素肯定会被迭代到，
    1032. * 但一个元素可能会被返回多次。
    1033. *
    1034. * For every element returned, the callback 'fn' passed as argument is
    1035. * called, with 'privdata' as first argument and the dictionar entry
    1036. * 'de' as second argument.
    1037. *
    1038. * 每当一个元素被返回时，回调函数 fn 就会被执行，
    1039. * fn 函数的第一个参数是 privdata ，而第二个参数则是字典节点 de 。
    1040. *
    1041. * HOW IT WORKS.
    1042. * 工作原理
    1043. *
    1044. * The algorithm used in the iteration was designed by Pieter Noordhuis.
    1045. * The main idea is to increment a cursor starting from the higher order
    1046. * bits, that is, instead of incrementing the cursor normally, the bits
    1047. * of the cursor are reversed, then the cursor is incremented, and finally
    1048. * the bits are reversed again.
    1049. *
    1050. * 迭代所使用的算法是由 Pieter Noordhuis 设计的，
    1051. * 算法的主要思路是在二进制高位上对游标进行加法计算
    1052. * 也即是说，不是按正常的办法来对游标进行加法计算，
    1053. * 而是首先将游标的二进制位翻转（reverse）过来，
    1054. * 然后对翻转后的值进行加法计算，
    1055. * 最后再次对加法计算之后的结果进行翻转。
    1056. *
    1057. * This strategy is needed because the hash table may be resized from one
    1058. * call to the other call of the same iteration.
    1059. *
    1060. * 这一策略是必要的，因为在一次完整的迭代过程中，
    1061. * 哈希表的大小有可能在两次迭代之间发生改变。
    1062. *
    1063. * dict.c hash tables are always power of two in size, and they
    1064. * use chaining, so the position of an element in a given table is given
    1065. * always by computing the bitwise AND between Hash(key) and SIZE-1
    1066. * (where SIZE-1 is always the mask that is equivalent to taking the rest
    1067. *  of the division between the Hash of the key and SIZE).
    1068. *
    1069. * 哈希表的大小总是 2 的某个次方，并且哈希表使用链表来解决冲突，
    1070. * 因此一个给定元素在一个给定表的位置总可以通过 Hash(key) & SIZE-1
    1071. * 公式来计算得出，
    1072. * 其中 SIZE-1 是哈希表的最大索引值，
    1073. * 这个最大索引值就是哈希表的 mask （掩码）。
    1074. *
    1075. * For example if the current hash table size is 16, the mask is
    1076. * (in binary) 1111. The position of a key in the hash table will be always
    1077. * the last four bits of the hash output, and so forth.
    1078. *
    1079. * 举个例子，如果当前哈希表的大小为 16 ，
    1080. * 那么它的掩码就是二进制值 1111 ，
    1081. * 这个哈希表的所有位置都可以使用哈希值的最后四个二进制位来记录。
    1082. *
    1083. * WHAT HAPPENS IF THE TABLE CHANGES IN SIZE?
    1084. * 如果哈希表的大小改变了怎么办？
    1085. *
    1086. * If the hash table grows, elements can go anyway in one multiple of
    1087. * the old bucket: for example let's say that we already iterated with
    1088. * a 4 bit cursor 1100, since the mask is 1111 (hash table size = 16).
    1089. *
    1090. * 当对哈希表进行扩展时，元素可能会从一个槽移动到另一个槽，
    1091. * 举个例子，假设我们刚好迭代至 4 位游标 1100 ，
    1092. * 而哈希表的 mask 为 1111 （哈希表的大小为 16 ）。
    1093. *
    1094. * If the hash table will be resized to 64 elements, and the new mask will
    1095. * be 111111, the new buckets that you obtain substituting in ??1100
    1096. * either 0 or 1, can be targeted only by keys that we already visited
    1097. * when scanning the bucket 1100 in the smaller hash table.
    1098. *
    1099. * 如果这时哈希表将大小改为 64 ，那么哈希表的 mask 将变为 111111 ，
    1100. *
    1101. * By iterating the higher bits first, because of the inverted counter, the
    1102. * cursor does not need to restart if the table size gets bigger, and will
    1103. * just continue iterating with cursors that don't have '1100' at the end,
    1104. * nor any other combination of final 4 bits already explored.
    1105. *
    1106. * Similarly when the table size shrinks over time, for example going from
    1107. * 16 to 8, If a combination of the lower three bits (the mask for size 8
    1108. * is 111) was already completely explored, it will not be visited again
    1109. * as we are sure that, we tried for example, both 0111 and 1111 (all the
    1110. * variations of the higher bit) so we don't need to test it again.
    1111. *
    1112. * WAIT... YOU HAVE *TWO* TABLES DURING REHASHING!
    1113. * 等等。。。在 rehash 的时候可是会出现两个哈希表的阿！
    1114. *
    1115. * Yes, this is true, but we always iterate the smaller one of the tables,
    1116. * testing also all the expansions of the current cursor into the larger
    1117. * table. So for example if the current cursor is 101 and we also have a
    1118. * larger table of size 16, we also test (0)101 and (1)101 inside the larger
    1119. * table. This reduces the problem back to having only one table, where
    1120. * the larger one, if exists, is just an expansion of the smaller one.
    1121. *
    1122. * LIMITATIONS
    1123. * 限制
    1124. *
    1125. * This iterator is completely stateless, and this is a huge advantage,
    1126. * including no additional memory used.
    1127. * 这个迭代器是完全无状态的，这是一个巨大的优势，
    1128. * 因为迭代可以在不使用任何额外内存的情况下进行。
    1129. *
    1130. * The disadvantages resulting from this design are:
    1131. * 这个设计的缺陷在于：
    1132. *
    1133. * 1) It is possible that we return duplicated elements. However this is usually
    1134. *    easy to deal with in the application level.
    1135. *    函数可能会返回重复的元素，不过这个问题可以很容易在应用层解决。
    1136. * 2) The iterator must return multiple elements per call, as it needs to always
    1137. *    return all the keys chained in a given bucket, and all the expansions, so
    1138. *    we are sure we don't miss keys moving.
    1139. *    为了不错过任何元素，
    1140. *    迭代器需要返回给定桶上的所有键，
    1141. *    以及因为扩展哈希表而产生出来的新表，
    1142. *    所以迭代器必须在一次迭代中返回多个元素。
    1143. * 3) The reverse cursor is somewhat hard to understand at first, but this
    1144. *    comment is supposed to help.
    1145. *    对游标进行翻转（reverse）的原因初看上去比较难以理解，
    1146. *    不过阅读这份注释应该会有所帮助。
    1147. */
    1148. unsigned long dictScan(dict *d,
    1149.                      unsigned long v,
    1150.                      dictScanFunction *fn,
    1151.                      void *privdata)
    1152. {
    1153.   dictht *t0, *t1;
    1154.   const dictEntry *de;
    1155.   unsigned long m0, m1;
    1156.   // 跳过空字典
    1157.   if (dictSize(d) == 0) return 0;
    1158.   // 迭代只有一个哈希表的字典
    1159.   if (!dictIsRehashing(d)) {
    1160.       // 指向哈希表
    1161.       t0 = &(d->ht[0]);
    1162.       // 记录 mask
    1163.       m0 = t0->sizemask;
    1164.       /* Emit entries at cursor */
    1165.       // 指向哈希桶
    1166.       de = t0->table[v & m0];
    1167.       // 遍历桶中的所有节点
    1168.       while (de) {
    1169.           fn(privdata, de);
    1170.           de = de->next;
    1171.       }
    1172.   // 迭代有两个哈希表的字典
    1173.   } else {
    1174.       // 指向两个哈希表
    1175.       t0 = &d->ht[0];
    1176.       t1 = &d->ht[1];
    1177.       /* Make sure t0 is the smaller and t1 is the bigger table */
    1178.       // 确保 t0 比 t1 要小
    1179.       if (t0->size > t1->size) {
    1180.           t0 = &d->ht[1];
    1181.           t1 = &d->ht[0];
    1182.       }
    1183.       // 记录掩码
    1184.       m0 = t0->sizemask;
    1185.       m1 = t1->sizemask;
    1186.       /* Emit entries at cursor */
    1187.       // 指向桶，并迭代桶中的所有节点
    1188.       de = t0->table[v & m0];
    1189.       while (de) {
    1190.           fn(privdata, de);
    1191.           de = de->next;
    1192.       }
    1193.       /* Iterate over indices in larger table that are the expansion
    1194.        * of the index pointed to by the cursor in the smaller table */
    1195.       // Iterate over indices in larger table             // 迭代大表中的桶
    1196.       // that are the expansion of the index pointed to   // 这些桶被索引的 expansion 所指向
    1197.       // by the cursor in the smaller table               //
    1198.       do {
    1199.           /* Emit entries at cursor */
    1200.           // 指向桶，并迭代桶中的所有节点
    1201.           de = t1->table[v & m1];
    1202.           while (de) {
    1203.               fn(privdata, de);
    1204.               de = de->next;
    1205.           }
    1206.           /* Increment bits not covered by the smaller mask */
    1207.           v = (((v | m0) + 1) & ~m0) | (v & m0);
    1208.           /* Continue while bits covered by mask difference is non-zero */
    1209.       } while (v & (m0 ^ m1));
    1210.   }
    1211.   /* Set unmasked bits so incrementing the reversed cursor
    1212.    * operates on the masked bits of the smaller table */
    1213.   v |= ~m0;
    1214.   /* Increment the reverse cursor */
    1215.   v = rev(v);
    1216.   v++;
    1217.   v = rev(v);
    1218.   return v;
    1219. }
    1220. /* ------------------------- private functions ------------------------------ */
    1221. /* Expand the hash table if needed */
    1222. /*
    1223. * 根据需要，初始化字典（的哈希表），或者对字典（的现有哈希表）进行扩展
    1224. *
    1225. * T = O(N)
    1226. */
    1227. static int _dictExpandIfNeeded(dict *d)
    1228. {
    1229.   /* Incremental rehashing already in progress. Return. */
    1230.   // 渐进式 rehash 已经在进行了，直接返回
    1231.   if (dictIsRehashing(d)) return DICT_OK;
    1232.   /* If the hash table is empty expand it to the initial size. */
    1233.   // 如果字典（的 0 号哈希表）为空，那么创建并返回初始化大小的 0 号哈希表
    1234.   // T = O(1)
    1235.   if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
    1236.   /* If we reached the 1:1 ratio, and we are allowed to resize the hash
    1237.    * table (global setting) or we should avoid it but the ratio between
    1238.    * elements/buckets is over the "safe" threshold, we resize doubling
    1239.    * the number of buckets. */
    1240.   // 一下两个条件之一为真时，对字典进行扩展
    1241.   // 1）字典已使用节点数和字典大小之间的比率接近 1：1
    1242.   //    并且 dict_can_resize 为真
    1243.   // 2）已使用节点数和字典大小之间的比率超过 dict_force_resize_ratio
    1244.   if (d->ht[0].used >= d->ht[0].size &&
    1245.       (dict_can_resize ||
    1246.        d->ht[0].used/d->ht[0].size > dict_force_resize_ratio))
    1247.   {
    1248.       // 新哈希表的大小至少是目前已使用节点数的两倍
    1249.       // T = O(N)
    1250.       return dictExpand(d, d->ht[0].used*2);
    1251.   }
    1252.   return DICT_OK;
    1253. }
    1254. /* Our hash table capability is a power of two */
    1255. /*
    1256. * 计算第一个大于等于 size 的 2 的 N 次方，用作哈希表的值
    1257. *
    1258. * T = O(1)
    1259. */
    1260. static unsigned long _dictNextPower(unsigned long size)
    1261. {
    1262.   unsigned long i = DICT_HT_INITIAL_SIZE;
    1263.   if (size >= LONG_MAX) return LONG_MAX;
    1264.   while(1) {
    1265.       if (i >= size)
    1266.           return i;
    1267.       i *= 2;
    1268.   }
    1269. }
    1270. /* Returns the index of a free slot that can be populated with
    1271. * a hash entry for the given 'key'.
    1272. * If the key already exists, -1 is returned.
    1273. *
    1274. * 返回可以将 key 插入到哈希表的索引位置
    1275. * 如果 key 已经存在于哈希表，那么返回 -1
    1276. *
    1277. * Note that if we are in the process of rehashing the hash table, the
    1278. * index is always returned in the context of the second (new) hash table. 
    1279. *
    1280. * 注意，如果字典正在进行 rehash ，那么总是返回 1 号哈希表的索引。
    1281. * 因为在字典进行 rehash 时，新节点总是插入到 1 号哈希表。
    1282. *
    1283. * T = O(N)
    1284. */
    1285. static int _dictKeyIndex(dict *d, const void *key)
    1286. {
    1287.   unsigned int h, idx, table;
    1288.   dictEntry *he;
    1289.   /* Expand the hash table if needed */
    1290.   // 单步 rehash
    1291.   // T = O(N)
    1292.   if (_dictExpandIfNeeded(d) == DICT_ERR)
    1293.       return -1;
    1294.   /* Compute the key hash value */
    1295.   // 计算 key 的哈希值
    1296.   h = dictHashKey(d, key);
    1297.   // T = O(1)
    1298.   for (table = 0; table <= 1; table++) {
    1299.       // 计算索引值
    1300.       idx = h & d->ht[table].sizemask;
    1301.       /* Search if this slot does not already contain the given key */
    1302.       // 查找 key 是否存在
    1303.       // T = O(1)
    1304.       he = d->ht[table].table[idx];
    1305.       while(he) {
    1306.           if (dictCompareKeys(d, key, he->key))
    1307.               return -1;
    1308.           he = he->next;
    1309.       }
    1310.       // 如果运行到这里时，说明 0 号哈希表中所有节点都不包含 key
    1311.       // 如果这时 rehahs 正在进行，那么继续对 1 号哈希表进行 rehash
    1312.       if (!dictIsRehashing(d)) break;
    1313.   }
    1314.   // 返回索引值
    1315.   return idx;
    1316. }
    1317. /*
    1318. * 清空字典上的所有哈希表节点，并重置字典属性
    1319. *
    1320. * T = O(N)
    1321. */
    1322. void dictEmpty(dict *d, void(callback)(void*)) {
    1323.   // 删除两个哈希表上的所有节点
    1324.   // T = O(N)
    1325.   _dictClear(d,&d->ht[0],callback);
    1326.   _dictClear(d,&d->ht[1],callback);
    1327.   // 重置属性 
    1328.   d->rehashidx = -1;
    1329.   d->iterators = 0;
    1330. }
    1331. /*
    1332. * 开启自动 rehash
    1333. *
    1334. * T = O(1)
    1335. */
    1336. void dictEnableResize(void) {
    1337.   dict_can_resize = 1;
    1338. }
    1339. /*
    1340. * 关闭自动 rehash
    1341. *
    1342. * T = O(1)
    1343. */
    1344. void dictDisableResize(void) {
    1345.   dict_can_resize = 0;
    1346. }
    1347. #if 0
    1348. /* The following is code that we don't use for Redis currently, but that is part
    1349. of the library. */
    1350. /* ----------------------- Debugging ------------------------*/
    1351. #define DICT_STATS_VECTLEN 50
    1352. static void _dictPrintStatsHt(dictht *ht) {
    1353.   unsigned long i, slots = 0, chainlen, maxchainlen = 0;
    1354.   unsigned long totchainlen = 0;
    1355.   unsigned long clvector[DICT_STATS_VECTLEN];
    1356.   if (ht->used == 0) {
    1357.       printf("No stats available for empty dictionaries\n");
    1358.       return;
    1359.   }
    1360.   for (i = 0; i < DICT_STATS_VECTLEN; i++) clvector[i] = 0;
    1361.   for (i = 0; i < ht->size; i++) {
    1362.       dictEntry *he;
    1363.       if (ht->table[i] == NULL) {
    1364.           clvector[0]++;
    1365.           continue;
    1366.       }
    1367.       slots++;
    1368.       /* For each hash entry on this slot... */
    1369.       chainlen = 0;
    1370.       he = ht->table[i];
    1371.       while(he) {
    1372.           chainlen++;
    1373.           he = he->next;
    1374.       }
    1375.       clvector[(chainlen < DICT_STATS_VECTLEN) ? chainlen : (DICT_STATS_VECTLEN-1)]++;
    1376.       if (chainlen > maxchainlen) maxchainlen = chainlen;
    1377.       totchainlen += chainlen;
    1378.   }
    1379.   printf("Hash table stats:\n");
    1380.   printf(" table size: %ld\n", ht->size);
    1381.   printf(" number of elements: %ld\n", ht->used);
    1382.   printf(" different slots: %ld\n", slots);
    1383.   printf(" max chain length: %ld\n", maxchainlen);
    1384.   printf(" avg chain length (counted): %.02f\n", (float)totchainlen/slots);
    1385.   printf(" avg chain length (computed): %.02f\n", (float)ht->used/slots);
    1386.   printf(" Chain length distribution:\n");
    1387.   for (i = 0; i < DICT_STATS_VECTLEN-1; i++) {
    1388.       if (clvector[i] == 0) continue;
    1389.       printf("   %s%ld: %ld (%.02f%%)\n",(i == DICT_STATS_VECTLEN-1)?">= ":"", i, clvector[i], ((float)clvector[i]/ht->size)*100);
    1390.   }
    1391. }
    1392. void dictPrintStats(dict *d) {
    1393.   _dictPrintStatsHt(&d->ht[0]);
    1394.   if (dictIsRehashing(d)) {
    1395.       printf("-- Rehashing into ht[1]:\n");
    1396.       _dictPrintStatsHt(&d->ht[1]);
    1397.   }
    1398. }
    1399. /* ----------------------- StringCopy Hash Table Type ------------------------*/
    1400. static unsigned int _dictStringCopyHTHashFunction(const void *key)
    1401. {
    1402.   return dictGenHashFunction(key, strlen(key));
    1403. }
    1404. static void *_dictStringDup(void *privdata, const void *key)
    1405. {
    1406.   int len = strlen(key);
    1407.   char *copy = zmalloc(len+1);
    1408.   DICT_NOTUSED(privdata);
    1409.   memcpy(copy, key, len);
    1410.   copy[len] = '\0';
    1411.   return copy;
    1412. }
    1413. static int _dictStringCopyHTKeyCompare(void *privdata, const void *key1,
    1414.       const void *key2)
    1415. {
    1416.   DICT_NOTUSED(privdata);
    1417.   return strcmp(key1, key2) == 0;
    1418. }
    1419. static void _dictStringDestructor(void *privdata, void *key)
    1420. {
    1421.   DICT_NOTUSED(privdata);
    1422.   zfree(key);
    1423. }
    1424. dictType dictTypeHeapStringCopyKey = {
    1425.   _dictStringCopyHTHashFunction, /* hash function */
    1426.   _dictStringDup,                /* key dup */
    1427.   NULL,                          /* val dup */
    1428.   _dictStringCopyHTKeyCompare,   /* key compare */
    1429.   _dictStringDestructor,         /* key destructor */
    1430.   NULL                           /* val destructor */
    1431. };
    1432. /* This is like StringCopy but does not auto-duplicate the key.
    1433. * It's used for intepreter's shared strings. */
    1434. dictType dictTypeHeapStrings = {
    1435.   _dictStringCopyHTHashFunction, /* hash function */
    1436.   NULL,                          /* key dup */
    1437.   NULL,                          /* val dup */
    1438.   _dictStringCopyHTKeyCompare,   /* key compare */
    1439.   _dictStringDestructor,         /* key destructor */
    1440.   NULL                           /* val destructor */
    1441. };
    1442. /* This is like StringCopy but also automatically handle dynamic
    1443. * allocated C strings as values. */
    1444. dictType dictTypeHeapStringCopyKeyValue = {
    1445.   _dictStringCopyHTHashFunction, /* hash function */
    1446.   _dictStringDup,                /* key dup */
    1447.   _dictStringDup,                /* val dup */
    1448.   _dictStringCopyHTKeyCompare,   /* key compare */
    1449.   _dictStringDestructor,         /* key destructor */
    1450.   _dictStringDestructor,         /* val destructor */
    1451. };
    1452. #endif


    © 著作权归作者所有
    打赏点赞 (1)收藏 (2)
    分享
    打印 举报
    上一篇：redis数据结构之zskiplist详解
    下一篇：Spring创建bean的三种方式

redis数据结构--dict - 图1

爱宝贝丶

redis数据结构--dict - 图2 redis数据结构--dict - 图3 redis数据结构--dict - 图4
粉丝 313

博文 126

码字总数 421718

作品 0
武汉

程序员
关注 私信 提问
相关文章最新文章
Redis 哈希结构内存模型剖析
本文共 1231字，阅读大约需要 5分钟 ！ —- 概述 在前文《Redis字符串类型内部编码剖析》之中已经剖析过 Redis最基本的 String类型的内部是怎么编码和存储的，本文再来阐述 Redis中使用 最为…
CodeSheep

2018/08/27

0

0
Redis 专栏(使用介绍、源码分析、常见问题…)
来源http://blog.csdn.net/yangbodong22011/article/details/78529448 https://github.com/hurley25 https://github.com/hurley25/ANet ANet 基于Redis网络模型的简易网络库，网络模块代码取……
libaineu2004

2017/12/16

0

0
Redis内部数据结构详解——skiplist
Redis内部数据结构详解(6)——skiplist 2016-10-05 本文是《Redis内部数据结构详解》系列的第六篇。在本文中，我们围绕一个Redis的内部数据结构——skiplist展开讨论。 Redis里面使用skiplis…
qwergkp

2018/11/09

0

0
Redis底部的几种存储结构（sds、dict、ziplist、intset、skiplist）
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u011734144/article/details/86086749 首先这里是原文： https://mp.weixin.qq.com/s?biz=MzA4NTg1MjM0Mg==&…
田野上的希望

01/08

0

0
redis数据结构--dict - 图5
Redis源码分析（dict）
源码版本： 源码位置： dict.h：等数据结构定义。 dict.c：创建、插入、查找等功能实现。 一、dict 简介 (dictionary 字典)，通常的存储结构是形式的，通过对key求Hash值来确定Value的位置，…
yangbodong22011