Redis详解（四）------ redis的底层数据结构

时间 2019-11-21

标签 redis 详解底层数据结构栏目 Redis 繁體版

原文原文链接

　　上一篇博客咱们介绍了 redis的五大数据类型详细用法，可是在 Redis 中，这几种数据类型底层是由什么数据结构构造的呢？本篇博客咱们就来详细介绍Redis中五大数据类型的底层实现。html

一、演示数据类型的实现

　　上篇博客咱们在介绍 key 相关命令的时候，介绍了以下命令：redis

OBJECT ENCODING    key

　　该命令是用来显示那五大数据类型的底层数据结构。算法

　　好比对于 string 数据类型：数据库

　　咱们能够看到实现string数据类型的数据结构有 embstr 以及 int。数组

　　再好比 list 数据类型：缓存

　　这里咱们就不作过多的演示了，那么上次出现的 embstr 以及 int 还有 quicklist 是什么数据结构呢？下面咱们就来介绍Redis中几种主要的数据结构。安全

二、简单动态字符串

　　第一篇文章咱们就说过 Redis 是用 C 语言写的，可是对于Redis的字符串，却不是 C 语言中的字符串（即以空字符’\0’结尾的字符数组），它是本身构建了一种名为简单动态字符串（simple dynamic string,SDS）的抽象类型，并将 SDS 做为 Redis的默认字符串表示。服务器

　　SDS 定义：数据结构

struct sdshdr{
     //记录buf数组中已使用字节的数量
     //等于 SDS 保存字符串的长度
     int len;
     //记录 buf 数组中未使用字节的数量
     int free;
     //字节数组，用于保存字符串
     char buf[];
}

　　用SDS保存字符串 “Redis”具体图示以下：函数

　　　　　　　　　图片来源：《Redis设计与实现》

　　咱们看上面对于 SDS 数据类型的定义：

　　一、len 保存了SDS保存字符串的长度

　　二、buf[] 数组用来保存字符串的每一个元素

　　三、free j记录了 buf 数组中未使用的字节数量

　　上面的定义相对于 C 语言对于字符串的定义，多出了 len 属性以及 free 属性。为何不使用C语言字符串实现，而是使用 SDS呢？这样实现有什么好处？

　　①、常数复杂度获取字符串长度

　　因为 len 属性的存在，咱们获取 SDS 字符串的长度只须要读取 len 属性，时间复杂度为 O(1)。而对于 C 语言，获取字符串的长度一般是通过遍历计数来实现的，时间复杂度为 O(n)。经过 strlen key 命令能够获取 key 的字符串长度。

　　②、杜绝缓冲区溢出

　　咱们知道在 C 语言中使用 strcat 函数来进行两个字符串的拼接，一旦没有分配足够长度的内存空间，就会形成缓冲区溢出。而对于 SDS 数据类型，在进行字符修改的时候，会首先根据记录的 len 属性检查内存空间是否知足需求，若是不知足，会进行相应的空间扩展，而后在进行修改操做，因此不会出现缓冲区溢出。

　　③、减小修改字符串的内存从新分配次数

　　C语言因为不记录字符串的长度，因此若是要修改字符串，必需要从新分配内存（先释放再申请），由于若是没有从新分配，字符串长度增大时会形成内存缓冲区溢出，字符串长度减少时会形成内存泄露。

　　而对于SDS，因为len属性和free属性的存在，对于修改字符串SDS实现了空间预分配和惰性空间释放两种策略：

　　一、空间预分配：对字符串进行空间扩展的时候，扩展的内存比实际须要的多，这样能够减小连续执行字符串增加操做所需的内存重分配次数。

　　二、惰性空间释放：对字符串进行缩短操做时，程序不当即使用内存从新分配来回收缩短后多余的字节，而是使用 free 属性将这些字节的数量记录下来，等待后续使用。（固然SDS也提供了相应的API，当咱们有须要时，也能够手动释放这些未使用的空间。）

　　④、二进制安全

　　由于C字符串以空字符做为字符串结束的标识，而对于一些二进制文件（如图片等），内容可能包括空字符串，所以C字符串没法正确存取；而全部 SDS 的API 都是以处理二进制的方式来处理 buf 里面的元素，而且 SDS 不是以空字符串来判断是否结束，而是以 len 属性表示的长度来判断字符串是否结束。

　　⑤、兼容部分 C 字符串函数

　　虽然 SDS 是二进制安全的，可是同样听从每一个字符串都是以空字符串结尾的惯例，这样能够重用 C 语言库<string.h> 中的一部分函数。

　　⑥、总结

　　通常来讲，SDS 除了保存数据库中的字符串值之外，SDS 还能够做为缓冲区（buffer）：包括 AOF 模块中的AOF缓冲区以及客户端状态中的输入缓冲区。后面在介绍Redis的持久化时会进行介绍。

三、链表

　　链表是一种经常使用的数据结构，C 语言内部是没有内置这种数据结构的实现，因此Redis本身构建了链表的实现。关于链表的详细介绍能够参考个人这篇博客。

　　链表定义：

typedef  struct listNode{
       //前置节点
       struct listNode *prev;
       //后置节点
       struct listNode *next;
       //节点的值
       void *value;   
}listNode

　　经过多个 listNode 结构就能够组成链表，这是一个双端链表，Redis还提供了操做链表的数据结构：

typedef struct list{
     //表头节点
     listNode *head;
     //表尾节点
     listNode *tail;
     //链表所包含的节点数量
     unsigned long len;
     //节点值复制函数
     void (*free) (void *ptr);
     //节点值释放函数
     void (*free) (void *ptr);
     //节点值对比函数
     int (*match) (void *ptr,void *key); 
}list;

　　Redis链表特性：

　　①、双端：链表具备前置节点和后置节点的引用，获取这两个节点时间复杂度都为O(1)。

　　②、无环：表头节点的 prev 指针和表尾节点的 next 指针都指向 NULL,对链表的访问都是以 NULL 结束。　　

　　③、带链表长度计数器：经过 len 属性获取链表长度的时间复杂度为 O(1)。

　　④、多态：链表节点使用 void* 指针来保存节点值，能够保存各类不一样类型的值。

四、字典

　　字典又称为符号表或者关联数组、或映射（map），是一种用于保存键值对的抽象数据结构。字典中的每个键 key 都是惟一的，经过 key 能够对值来进行查找或修改。C 语言中没有内置这种数据结构的实现，因此字典依然是 Redis本身构建的。

　　Redis 的字典使用哈希表做为底层实现，关于哈希表的详细讲解能够参考我这篇博客。

　　哈希表结构定义：

typedef struct dictht{
     //哈希表数组
     dictEntry **table;
     //哈希表大小
     unsigned long size;
     //哈希表大小掩码，用于计算索引值
     //老是等于 size-1
     unsigned long sizemask;
     //该哈希表已有节点的数量
     unsigned long used;

}dictht

　　哈希表是由数组 table 组成，table 中每一个元素都是指向 dict.h/dictEntry 结构，dictEntry 结构定义以下：

typedef struct dictEntry{
     //键
     void *key;
     //值
     union{
          void *val;
          uint64_tu64;
          int64_ts64;
     }v;

     //指向下一个哈希表节点，造成链表
     struct dictEntry *next;
}dictEntry

　　key 用来保存键，val 属性用来保存值，值能够是一个指针，也能够是uint64_t整数，也能够是int64_t整数。

　　注意这里还有一个指向下一个哈希表节点的指针，咱们知道哈希表最大的问题是存在哈希冲突，如何解决哈希冲突，有开放地址法和链地址法。这里采用的即是链地址法，经过next这个指针能够将多个哈希值相同的键值对链接在一块儿，用来解决哈希冲突。

　　①、哈希算法：Redis计算哈希值和索引值方法以下：

#一、使用字典设置的哈希函数，计算键 key 的哈希值
hash = dict->type->hashFunction(key);
#二、使用哈希表的sizemask属性和第一步获得的哈希值，计算索引值
index = hash & dict->ht[x].sizemask;

　　②、解决哈希冲突：这个问题上面咱们介绍了，方法是链地址法。经过字典里面的 *next 指针指向下一个具备相同索引值的哈希表节点。

　　③、扩容和收缩：当哈希表保存的键值对太多或者太少时，就要经过 rerehash(从新散列）来对哈希表进行相应的扩展或者收缩。具体步骤：

　　　　　　一、若是执行扩展操做，会基于原哈希表建立一个大小等于 ht[0].used*2n 的哈希表（也就是每次扩展都是根据原哈希表已使用的空间扩大一倍建立另外一个哈希表）。相反若是执行的是收缩操做，每次收缩是根据已使用空间缩小一倍建立一个新的哈希表。

　　　　　　二、从新利用上面的哈希算法，计算索引值，而后将键值对放到新的哈希表位置上。

　　　　　　三、全部键值对都迁徙完毕后，释放原哈希表的内存空间。

　　④、触发扩容的条件：

　　　　　　一、服务器目前没有执行 BGSAVE 命令或者 BGREWRITEAOF 命令，而且负载因子大于等于1。

　　　　　　二、服务器目前正在执行 BGSAVE 命令或者 BGREWRITEAOF 命令，而且负载因子大于等于5。

　　　　ps：负载因子 = 哈希表已保存节点数量 / 哈希表大小。

　　⑤、渐近式 rehash

　　　　什么叫渐进式 rehash？也就是说扩容和收缩操做不是一次性、集中式完成的，而是分屡次、渐进式完成的。若是保存在Redis中的键值对只有几个几十个，那么 rehash 操做能够瞬间完成，可是若是键值对有几百万，几千万甚至几亿，那么要一次性的进行 rehash，势必会形成Redis一段时间内不能进行别的操做。因此Redis采用渐进式 rehash,这样在进行渐进式rehash期间，字典的删除查找更新等操做可能会在两个哈希表上进行，第一个哈希表没有找到，就会去第二个哈希表上进行查找。可是进行增长操做，必定是在新的哈希表上进行的。

五、跳跃表

　　关于跳跃表的趣味介绍：http://blog.jobbole.com/111731/

　　跳跃表（skiplist）是一种有序数据结构，它经过在每一个节点中维持多个指向其它节点的指针，从而达到快速访问节点的目的。具备以下性质：

　　一、由不少层结构组成；

　　二、每一层都是一个有序的链表，排列顺序为由高层到底层，都至少包含两个链表节点，分别是前面的head节点和后面的nil节点；

　　三、最底层的链表包含了全部的元素；

　　四、若是一个元素出如今某一层的链表中，那么在该层之下的链表也全都会出现（上一层的元素是当前层的元素的子集）；

　　五、链表中的每一个节点都包含两个指针，一个指向同一层的下一个链表节点，另外一个指向下一层的同一个链表节点；

　　Redis中跳跃表节点定义以下：

typedef struct zskiplistNode {
     //层
     struct zskiplistLevel{
           //前进指针
           struct zskiplistNode *forward;
           //跨度
           unsigned int span;
     }level[];

     //后退指针
     struct zskiplistNode *backward;
     //分值
     double score;
     //成员对象
     robj *obj;

} zskiplistNode

　　多个跳跃表节点构成一个跳跃表：

typedef struct zskiplist{
     //表头节点和表尾节点
     structz skiplistNode *header, *tail;
     //表中节点的数量
     unsigned long length;
     //表中层数最大的节点的层数
     int level;

}zskiplist;

　　①、搜索：从最高层的链表节点开始，若是比当前节点要大和比当前层的下一个节点要小，那么则往下找，也就是和当前层的下一层的节点的下一个节点进行比较，以此类推，一直找到最底层的最后一个节点，若是找到则返回，反之则返回空。

　　②、插入：首先肯定插入的层数，有一种方法是假设抛一枚硬币，若是是正面就累加，直到碰见反面为止，最后记录正面的次数做为插入的层数。当肯定插入的层数k后，则须要将新元素插入到从底层到k层。

　　③、删除：在各个层中找到包含指定值的节点，而后将节点从链表中删除便可，若是删除之后只剩下头尾两个节点，则删除这一层。

六、整数集合

　　整数集合（intset）是Redis用于保存整数值的集合抽象数据类型，它能够保存类型为int16_t、int32_t 或者int64_t 的整数值，而且保证集合中不会出现重复元素。

　　定义以下：

typedef struct intset{
     //编码方式
     uint32_t encoding;
     //集合包含的元素数量
     uint32_t length;
     //保存元素的数组
     int8_t contents[];

}intset;

　　整数集合的每一个元素都是 contents 数组的一个数据项，它们按照从小到大的顺序排列，而且不包含任何重复项。

　　length 属性记录了 contents 数组的大小。

　　须要注意的是虽然 contents 数组声明为 int8_t 类型，可是实际上contents 数组并不保存任何 int8_t 类型的值，其真正类型有 encoding 来决定。

　　①、升级

　　当咱们新增的元素类型比原集合元素类型的长度要大时，须要对整数集合进行升级，才能将新元素放入整数集合中。具体步骤：

　　一、根据新元素类型，扩展整数集合底层数组的大小，并为新元素分配空间。

　　二、将底层数组现有的全部元素都转成与新元素相同类型的元素，并将转换后的元素放到正确的位置，放置过程当中，维持整个元素顺序都是有序的。

　　三、将新元素添加到整数集合中（保证有序）。

　　升级能极大地节省内存。

　　②、降级

　　整数集合不支持降级操做，一旦对数组进行了升级，编码就会一直保持升级后的状态。

七、压缩列表

　　压缩列表（ziplist）是Redis为了节省内存而开发的，是由一系列特殊编码的连续内存块组成的顺序型数据结构，一个压缩列表能够包含任意多个节点（entry），每一个节点能够保存一个字节数组或者一个整数值。

　　压缩列表的原理：压缩列表并非对数据利用某种算法进行压缩，而是将数据按照必定规则编码在一块连续的内存区域，目的是节省内存。

　　压缩列表的每一个节点构成以下：

　　①、previous_entry_ength：记录压缩列表前一个字节的长度。previous_entry_ength的长度多是1个字节或者是5个字节，若是上一个节点的长度小于254，则该节点只须要一个字节就能够表示前一个节点的长度了，若是前一个节点的长度大于等于254，则previous length的第一个字节为254，后面用四个字节表示当前节点前一个节点的长度。利用此原理即当前节点位置减去上一个节点的长度即获得上一个节点的起始位置，压缩列表能够从尾部向头部遍历。这么作颇有效地减小了内存的浪费。

　　②、encoding：节点的encoding保存的是节点的content的内容类型以及长度，encoding类型一共有两种，一种字节数组一种是整数，encoding区域长度为1字节、2字节或者5字节长。

　　③、content：content区域用于保存节点的内容，节点内容类型和长度由encoding决定。

八、总结

　　大多数状况下，Redis使用简单字符串SDS做为字符串的表示，相对于C语言字符串，SDS具备常数复杂度获取字符串长度，杜绝了缓存区的溢出，减小了修改字符串长度时所需的内存重分配次数，以及二进制安全能存储各类类型的文件，而且还兼容部分C函数。

　　经过为链表设置不一样类型的特定函数，Redis链表能够保存各类不一样类型的值，除了用做列表键，还在发布与订阅、慢查询、监视器等方面发挥做用（后面会介绍）。

　　Redis的字典底层使用哈希表实现，每一个字典一般有两个哈希表，一个平时使用，另外一个用于rehash时使用，使用链地址法解决哈希冲突。

　　跳跃表一般是有序集合的底层实现之一，表中的节点按照分值大小进行排序。

　　整数集合是集合键的底层实现之一，底层由数组构成，升级特性能尽量的节省内存。

　　压缩列表是Redis为节省内存而开发的顺序型数据结构，一般做为列表键和哈希键的底层实现之一。

　　以上介绍的简单字符串、链表、字典、跳跃表、整数集合、压缩列表等数据结构就是Redis底层的一些数据结构，用来实现上一篇博客介绍的Redis五大数据类型，那么每种数据类型是由哪些数据结构实现的呢？下一篇博客进行介绍。

参考文档：《Redis设计与实现》