Redis数据库内部结构解析-CSDN博客

Redis 是支持多key-value数据库,并用 RedisDb 来表示一个key-value数据库. redisServer 中有一个 redisDb *db成员变量, RedisServer 在初始化时,会根据配置文件的 db 数量来创建一个 redisDb 数组. 客户端在连接后,通过 SELECT 指令来选择一个 reidsDb,如果不指定,则缺省是redisDb数组的第1个(即下标是 0 ) redisDb. 一个客户端在选择 redisDb 后,其后续操作都是在此 redisDb 上进行的. 下面是redisDb结构体

  1: 
  2: /*
  3:  * 数据库结构
  4:  */
  5: typedef struct redisDb {
  6:     // key space，包括键值对象
  7:     dict *dict;                 /* The keyspace for this DB */
  8:     // 保存 key 的过期时间
  9:     dict *expires;              /* Timeout of keys with a timeout set */
 10:     // 正因为某个/某些 key 而被阻塞的客户端
 11:     dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP) */
 12:     // 某个/某些接收到 PUSH 命令的阻塞 key
 13:     dict *ready_keys;           /* Blocked keys that received a PUSH */
 14:     // 正在监视某个/某些 key 的所有客户端
 15:     dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
 16:     // 数据库的号码
 17:     int id;
 18: } redisDb;
 19:

其中redisDb结构中包含指向dict结构的指针，这个指针指向了字典结构，下面我们具体分析字典结构的用途、组成和一些操作

Redis中dict的主要应用

dict的主要用途有两个：

1.实现数据库的键空间

2.用作hash类型键的一种实现

实现数据库键空间
Redis 是一个键值对数据库，数据库中的键值对就由字典保存：每个数据库都有一个与之相对
应的字典，这个字典被称之为键空间（key space）。
当用户添加一个键值对到数据库时（不论键值对是什么类型），程序就将该键值对添加到键空
间；当用户从数据库中删除一个键值对时，程序就会将这个键值对从键空间中删除；等等

用作 Hash 类型键的其中一种底层实现
Redis 的 Hash 类型键使用以下两种数据结构作为底层实现:
1. 字典；
2. 压缩列表；

dict的实现

Redis用hash表作为字典的底层实现

下面给出dict结构的定义

  1: 
  2: /*
  3:  * 字典
  4:  *
  5:  * 每个字典使用两个哈希表，用于实现渐进式 rehash
  6:  */
  7: typedef struct dict {
  8: 
  9:     // 特定于类型的处理函数
 10:     dictType *type;
 11: 
 12:     // 类型处理函数的私有数据
 13:     void *privdata;
 14: 
 15:     // 哈希表（2个）
 16:     dictht ht[2];       
 17: 
 18:     // 记录 rehash 进度的标志，值为-1 表示 rehash 未进行
 19:     int rehashidx;
 20: 
 21:     // 当前正在运作的安全迭代器数量
 22:     int iterators;      
 23: 
 24: } dict;
 25:

其中dict结构中包含一个具有两个hash表的数组，hash表用dictht结构体表示，下面是其具体实现：

  1: 
  2: /*
  3:  * 哈希表
  4:  */
  5: typedef struct dictht {
  6: 
  7:     // 哈希表节点指针数组（俗称桶，bucket）
  8:     dictEntry **table;      
  9: 
 10:     // 指针数组的大小
 11:     unsigned long size;     
 12: 
 13:     // 指针数组的长度掩码，用于计算索引值
 14:     unsigned long sizemask; 
 15: 
 16:     // 哈希表现有的节点数量
 17:     unsigned long used;     
 18: 
 19: } dictht;
 20:

table实际是一个数组，数组的元素是指向dictEntry的指针，而每一个dictEntry保存着一个键值对，还有一个指向另一个dictEntry结构的指针

  1: 
  2: /*
  3:  * 哈希表节点
  4:  */
  5: typedef struct dictEntry {
  6: 
  7:     // 键
  8:     void *key;
  9: 
 10:     // 值
 11:     union {
 12:         void *val;
 13:         uint64_t u64;
 14:         int64_t s64;
 15:     } v;
 16: 
 17:     // 链往后继节点
 18:     struct dictEntry *next; 
 19: 
 20: } dictEntry;
 21:

其中多个dictEnty通过其中的next指针可以构成链表，而redis中的hash表使用链接地址法处理碰撞，当多个不同的键具有相同的哈希值时，采用链接的方法将它们连接成一个链表

下图是整个dict字典结构的图示：

rehash

使用链地址法来解决碰撞问题的哈希表dictht来说，哈希表的性能依赖于它的大小（size属性）和它所保存的节点的数量（used 属性）之间的比率

• 比率在 1:1 时，哈希表的性能最好；
• 如果节点数量比哈希表的大小要大很多的话，那么哈希表就会退化成多个链表，哈希表本身的性能优势就不再存在

为了在键值对不断增加的情况下继续保持高性能，字典需要对hash表进行rehash，对hash表进行扩容

那么什么情况下会进行hash表的扩容呢？

dictAdd 在每次向字典添加新键值对之前，都会对哈希表 ht[0] 进行检查，对于 ht[0] 的size 和 used 属性，如果它们之间的比率 ratio = used / size 满足以下任何一个条件的话，rehash 过程就会被激活：

1. 自然 rehash ：ratio >= 1 ，且变量 dict_can_resize 为真。
2. 强制 rehash ： ratio 大于变量 dict_force_resize_ratio

rehash执行过程

字典的 rehash 操作实际上就是执行以下任务：

1. 创建一个比 ht[0]->table 更大的 ht[1]->table(ht[1]的size是ht[0]的两倍) ；

2. 将 ht[0]->table 中的所有键值对迁移到 ht[1]->table

3. 将原有 ht[0] 的数据清空，并将 ht[1] 替换为新的 ht[0]

当然rehash并不是在激活或就立即执行的，而是渐进地、分多次进行的

因为服务器不能一直阻塞等待rehash完成才处理客户到达的命令，所以我们采用渐进的rehash方法：

渐进式 rehash 主要由 _dictRehashStep 和 dictRehashMilliseconds 两个函数进行：
• _dictRehashStep 用于对数据库字典、以及哈希键的字典进行被动 rehash ；
• dictRehashMilliseconds 则由 Redis 服务器常规任务程序（server cron job）执行，用于对数据库字典进行主动 rehash ；

每次执行 _dictRehashStep ，ht[0]->table 哈希表第一个不为空的索引上的所有节点就会全部迁移到 ht[1]->table ,在 rehash 开始进行之后（d->rehashidx 不为 -1），每次执行一次添加、查找、删除操作，_dictRehashStep 都会被执行一次：

dictRehashMilliseconds 可以在指定的毫秒数内，对字典进行 rehash

当 Redis 的服务器常规任务执行时(serverCrom)，dictRehashMilliseconds 会被执行，在规定的时间内，尽可能地对数据库字典中那些需要 rehash 的字典进行 rehash ，从而加速数据库字典的 rehash进程（progress）

其他注意事项

在哈希表进行 rehash 时，字典还会采取一些特别的措施，确保 rehash 顺利、正确地进行：
• 因为在 rehash 时，字典会同时使用两个哈希表，所以在这期间的所有查找、删除等操作，除了在 ht[0] 上进行，还需要在 ht[1] 上进行
• 在执行添加操作时，新的节点会直接添加到 ht[1] 而不是 ht[0] ，这样保证 ht[0] 的节点数量在整个 rehash 过程中都只减不增