Redis现在是比较流行的缓存数据库，一般刚接触的时候都会发现其可以存储字符串（string）、哈希表（hash）、列表（list）、集合（set）、有序集合（sorted set）等。redis是一个key-value存储，value可以包含上面列出的多种结构，但是key都是字符串。也就是说key是string类型，value为上面类型的一种。

由于以上每种数据结构的存储指令在redis中都不一样，单个看来想要使用redis必须要先区分要存储的对象的结构，然后选择相应的指令。但是这样使用起来确实是很不利的，如果一次要存入多种形式的值，我就要实现多种存储方式。

为了便于开发和使用redis引入了对象，即对象存储。上面的每种数据结构都是一种对象，所以，在项目中只需要实现对象的存储即可。

Redis中每个对象都有一个redisObject结构，该结构中和保存数据相关的三种属性分别是存储数据的类型type、值的编码属性encoding和指针ptr属性：

typedef struct redisObject{
//类型
unsigned type:4;

//编码
unsigned encoding:4;

//指向底层实现数据结构的指针
void *ptr

//虚拟内存和其他信息等.....
}robj;

类型常量	对象的名称	type值
REDIS_STRING	字符串对象	string
REDIS_LIST	列表对象	list
REDIS_HASH	哈希对象	hash
REDIS_SET	集合对象	set
REDIS_ZSET	有序集合对象	zset

获取存储值的类型编码指令：
TYPE key

如，我在redis中存入一个字符串的值：

[root@iZ8vb8r420ejxfron03cj7Z ~]# redis-cli
127.0.0.1:6379> set msg "rhett"  
OK
127.0.0.1:6379> get msg
"rhett"
127.0.0.1:6379> type msg
string

编码常量	对象的名称	type值
REDIS_ENCODING_INT	整数	int
REDIS_ENCODING_EMBSTR	embstr编码的简单动态字符串(SDS)	list
REDIS_ENCODING_RAW	简单动态字符串	raw
REDIS_ENCODING_HT	字典	hashtable
REDIS_ENCODING_LINKEDLIST	双端链表	linkedlist
REDIS_ENCODING_ZIPLIST	压缩列表	ziplist
REDIS_ENCODING_INTSET	整数集合	intset
REDIS_ENCODING_SKIPLIST	跳跃表和字典	skiplist

redis中的示例：

[root@iZ8vb8r420ejxfron03cj7Z ~]# redis-cli
127.0.0.1:6379> set msg "rhett"  
OK
127.0.0.1:6379> object encoding msg
"embstr"

特点：快速、非关系、内存存储、不使用表（必要时才用，少量数据，专属命令）

比较：MySQL:关系数据库，大量，增改删查

Redis:服务器关闭时，紧凑的格式将存储在内存中的数据写入硬盘

持久化方法：1.时间点转储：指定时间段内有指定数量的写操作执行

2.将所有修改了数据库的命令全部写入一个只追加文件里面

结构类型（5种）

String:字符串、整数、浮点数

List:链表

Set:唯一无序集，不重复

Hash：键值对，无序散列表

Zset：有序集

String命令：对给定键中的值获取GET、设置SET、删除DEL

$redis-cli

redis 127.0.0.1:6379>set hello world

redis 127.0.0.1:6379>get hello

redis 127.0.0.1:6379>del hello

List:

RPUSH:推入右端,返回长度

LRANGE:获取列表在给定范围上的所有值

LINDEX:获取列表在给定位置上的单个元素

LPOP:从左端弹出一个值并返回弹出的值

Set:

SADD:将给定元素加入集合

SMEMBERS:返回集合包含的所有元素

SISMEMBER:检查给定元素是否存在于集合中

SREM：如果在，移除

Hash:

HSET:关联指定键值对

HGET：获取键的值

HGETALL：获取所有键值对

HDEL：移除键

Zset:

ZADD:给定分值的成员添加到有序集合里

ZRANGE:根据元素位置，从中取多个元素

ZRANGEBYSCORE:获取给的分值范围内所有元素

ZREM:删除给定成员

下面以redis3.2的正式版源码分析集中存储机构：

在Redis内部，有非常多的数据结构：sds（简单动态字符串），list，intset（整数集合），hash（字典），zskiplist（跳跃表），ziplist（压缩表）等。

1. sds

 
     typedef char *sds; 
    

sds是一种简单动态字符串，而sdshdr封装了C原生字符串，并在其基础上，增加了一些功能，使之后对它的调用简单易懂可扩展。

 
     /*下面是sds数据结构的具体实现*/ 
    
     /* Note: sdshdr5 is never used, we just access the flags byte directly. 
    
     * However is here to document the layout of type 5 SDS strings. */ 
    
     struct __attribute__ ((__packed__)) sdshdr5 { 
    
     unsigned char flags; /* 3 lsb of type, and 5 msb of string length */ 
    
     char buf[]; 
    
     }; 
    
     struct __attribute__ ((__packed__)) sdshdr8 { 
    
     uint8_t len; /* used */ 
    
     uint8_t alloc; /* excluding the header and null terminator */ 
    
     unsigned char flags; /* 3 lsb of type, 5 unused bits */ 
    
     char buf[]; 
    
     }; 
    
     struct __attribute__ ((__packed__)) sdshdr16 { 
    
     uint16_t len; /* used */ 
    
     uint16_t alloc; /* excluding the header and null terminator */ 
    
     unsigned char flags; /* 3 lsb of type, 5 unused bits */ 
    
     char buf[]; 
    
     }; 
    
     struct __attribute__ ((__packed__)) sdshdr32 { 
    
     uint32_t len; /* used */ 
    
     uint32_t alloc; /* excluding the header and null terminator */ 
    
     unsigned char flags; /* 3 lsb of type, 5 unused bits */ 
    
     char buf[]; 
    
     }; 
    
     struct __attribute__ ((__packed__)) sdshdr64 { 
    
     uint64_t len; /* used */ 
    
     uint64_t alloc; /* excluding the header and null terminator */ 
    
     unsigned char flags; /* 3 lsb of type, 5 unused bits */ 
    
     char buf[]; 
    
     };

这是sdshdr的具体实现结构体，它作为sds的持有者，对sds进行存储和处理，len表示sds的长度，alloc表示分配了的长度，这样方便扩展；flags标志来判断使用哪个类型；buf[]则作为sds的真正储存数组，关系大致如下：

Redis采用动态字符串的形式，用len记录长度，这样可以在O（1）的复杂度内获取字符串长度；根据不同的类型和字符串的长短，分别用不同类型的sdshdr，可以节约不少空间；将alloc和len分离，可以在一定的范围内节省分配内存所用的时间；在Redis中，运用了大量的指针移动技巧来获取void*对象，也提高了程序的运行效率。例如：

 
     #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T)))) 
    

通过s-sizeof（sdshdr）来获取sdshdr的地址；再如：

 
     static inline size_t sdslen(const sds s) { 
    
     unsigned char flags = s[-1]; 
    
     switch(flags&SDS_TYPE_MASK) { 
    
     case SDS_TYPE_5: 
    
     return SDS_TYPE_5_LEN(flags); 
    
     case SDS_TYPE_8: 
    
     return SDS_HDR(8,s)->len; 
    
     case SDS_TYPE_16: 
    
     return SDS_HDR(16,s)->len; 
    
     case SDS_TYPE_32: 
    
     return SDS_HDR(32,s)->len; 
    
     case SDS_TYPE_64: 
    
     return SDS_HDR(64,s)->len; 
    
     } 
    
     return 0; 
    
     }

运用s[-1]来获取flags，判断类型。

其实，运用指针的移动而不是数组的下标，还保证了字符串的二进制安全，在遇到'\0'的情况下不会中断。

sds字符串在Redis里的应用：

1.保存数据库中字符串的值

2.用作缓冲区:

AOF模块的缓冲区，

客户端状态中的输入缓冲区。

2.list

看看list的实现，非常有助于复习一遍数据结构中链表的实现原理，建议大家仔细阅读源码。

 
     typedef struct listNode { /*节点*/ 
    
     struct listNode *prev; 
    
     struct listNode *next; 
    
     void *value; /*value用函数指针类型，决定了value可以是sds，list，set，dict等类型*/ 
    
     } listNode;

以上是listNode的数据结构。

 
      typedef struct list { /*链表结构*/ 
     
      listNode *head; /*头节点*/ 
     
      listNode *tail; /*尾节点*/ 
     
      /*类似java类里的的方法，方便调用*/ 
     
      void *(*dup)(void *ptr); /*复制节点*/ //说实话，我不是很懂这个函数指针的意思，如有清楚地可以给我留言，谢谢。 
     
      void (*free)(void *ptr); /*释放节点*/ 
     
      int (*match)(void *ptr, void *key); /*匹配节点，返回key值得index，但是我不清楚他在那里实现的*/ 
     
      unsigned long len; /*记录链表的长度*/ 
     
      } list;

Redis中，list的实现是一个双端链表，这样可以方便的获取其前后的节点值，方便之后对节点的查找；Redis通过list来对listNode进行持有，分别记录list的头尾节点和list长度，可在O（1）的时间复杂度上进行查找；

另外，list还实现了迭代器对链表进行遍历，可正向可反向，非常方便，代码如下；

 
     typedef struct listIter { 
    
     listNode *next; 
    
     int direction; //标注迭代器的运行方向 
    
     } listIter;

list在Redis中运用相当广泛，除了实现列表外，发布和订阅、慢查询、监视器等功能也使用了链表来获取，另外，Redis服务器还使用链表来持有多个客户端的状态信息，以及用链表来构建客户端输出缓冲区。

注：Redis中void* 来修饰value值，所以value可以是任意类型的数据，void*在这里实现了一种类似多态的思想。

3.dict（字典）

字典结构是整个Redis的核心数据结构，基本上是其内部结构的缩影。

 
     typedef struct dictEntry { 
    
     void *key; 
    
     union { 
    
     void *val; 
    
     uint64_t u64; 
    
     int64_t s64; 
    
     double d; 
    
     } v; 
    
     struct dictEntry *next; 
    
     } dictEntry;

dictEntry是最核心的字典结构的节点结构，它保存了key和value的内容；另外，next指针是为了解决hash冲突，字典结构的hash冲突解决方法是拉链法，对于hashcode重复的节点以链表的形式存储。

 
     typedef struct dictht { 
    
     dictEntry **table; 
    
     unsigned long size; 
    
     unsigned long sizemask; /*hash表的掩码，总是size-1，用于计算hash表的索引值*/ 
    
     unsigned long used; 
    
     } dictht;

dictht是节点dictEntry的持有者，将dictEntry结构串起来，table就是hash表，其实dictEntry *table[]这样的书写方式更容易理解些，size就是table数组的长度，used标志已有节点的数目。

 
     typedef struct dict { 
    
     dictType *type; 
    
     void *privdata; 
    
     dictht ht[2]; 
    
     long rehashidx; /* rehashing not in progress if rehashidx == -1 */ 
    
     int iterators; /* number of iterators currently running */ 
    
     } dict;

dict是最外层的字典结构的接口形式，type标志类型，privdata标志其私有数据，dict持有两个dictht结构，一个用来存储数据，一个用来在rehash时使用，rehashidx标志是否正在rehash（因为Redis中rehash是一个渐近的过程，正在rehash的时候rehashidx记录rehash的阶段，否则为-1）。

注：rehash是一个为了让负载因子（load_factor=used/size）控制在一个合理的范围内而重新分配内存和扩展结构的过程。

iterators是一个迭代器，用于记录当前迭代的数目。

上面的图来自网络，非常清晰的记录了dict内部结构之间的关系。

注：因为dictEntry节点组成的链表没有子项链表尾部的指针，所以新加的节点一般都加在链表的头部，排在已有节点的前面，因为这样的时间复杂度为O(1)。

字典结构在Redis中广泛应用，包括数据库和hash键值对。

4.intset

 
     typedef struct intset { /*整数集合的数据结构*/ 
    
     uint32_t encoding; //编码方式 
    
     uint32_t length; 
    
     int8_t contents[]; 
    
     } intset;

当一个集合元素只有整数并且数量元素不多的时候，可以选择用整数集合来作为其底层实现。整数集合的数据结构如上所示。

重点说一下这个contents数组，它存储集合中的内容，并且以从小到大的顺序排列，并保证其没有重复的元素。

虽然定义中其类型为int8_t，但具体编码方式还是取决于encoding。

当最大的数在以上取值范围之内是便会升级到这个更大范围的数据类型，但是如果移除了这个最大取值，不会降级。

分范围定义其类型有两个好处：提高其灵活性，节约内存。但是也增加了升级的开销。

在Redis 中，整数集合的应用范围不是很广，只在实现集合时用到。

5. zskiplist（跳跃表）

对于不了解跳跃表的可以去这个地方看看，了解一下： http://blog.nosqlfan.com/html/3041.html。

跳表是一种实现起来很简单，单层多指针的链表，它查找效率很高，堪比优化过的二叉平衡树，且比平衡树的实现，简单的多的多。

 
     typedef struct zskiplistNode { 
    
     robj *obj; //存储对象的指针 
    
     double score; //分数 
    
     struct zskiplistNode *backward; //后退指针，每次只能退一步 
    
     struct zskiplistLevel { 
    
     struct zskiplistNode *forward; //前进指针，每次可以跳跃好几步 
    
     unsigned int span; //这个就是决定前进指针能跳跃几步的跨度标志 
    
     } level[]; 
    
     } zskiplistNode;

zskiplistNode是跳跃表的节点结构，obj指针指向存储具体对象的地址，score标志分数。

 
     typedef struct zskiplist { 
    
     struct zskiplistNode *header, *tail; 
    
     unsigned long length; 
    
     int level; 
    
     } zskiplist;

zskiplist持有节点，并记录头结点和尾节点以及长度，level记录层数最大的节点的层数，也就是zskiplistNode中最大的level.size。

上图来自于一本非常经典的书籍《Redis的设计与实现》。非常清晰的勾勒了跳跃表的数据结构，单看这个图，就知道其查找效率高于链表。这是一种用空间来换时间的链表实现。

注：其层次的分配是随机的，下面是其随机生成的算法，非常简单。

 
    int zslRandomLevel(void) { 
   
    int level = 1; 
   
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF)) 
   
    level += 1; 
   
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL; 
   
    }

跳表在Redis中仅仅作为zset（有序集合）的底层实现出现，所以其数据结构定义在server.h中，其实现函数在t_zset.c中。

6.ziplist（压缩表）

ziplist是一个编码后的列表，是由一系列特殊编码的连续内存块组成的顺序型数据结构，特殊的设计使得内存操作非常有效率，此列表可以同时存放字符串和整数类型，列表可以在头尾各边支持推加和弹出操作在O(1)常量时间,但是，因为每次操作涉及到内存的重新分配释放，所以加大了操作的复杂性。

 
     typedef struct zlentry { 
    
     //prevrawlen为上一个数据结点的长度，prevrawlensize为记录该长度数值所需要的字节数 
    
     unsigned int prevrawlensize, prevrawlen; 
    
     //len为当前数据结点的长度，lensize表示表示当前长度表示所需的字节数 
    
     unsigned int lensize, len; 
    
     //数据结点的头部信息长度的字节数 
    
     unsigned int headersize; 
    
     //编码的方式 
    
     unsigned char encoding; 
    
     //数据结点的数据(已包含头部等信息)，以字符串形式保存 
    
     unsigned char *p; 
    
     } zlentry;

zlentry是实际存储数据的节点。一个ziplist可以有多个zlentry节点，具体形式如下：

压缩表之所以成为压缩表，是因为它起到了一定的压缩功能，对于其他的数据结构为了快速定位，使用了大量的指针结构，这样对于长度较大的数据优势明显，但是对于长度非常小的数据，比如说一个表里的每一个数据长度都很短，但是数据量并不小，这样的话，就会出现大量的指针结构，造成内存浪费，而压缩表则分配了一块连续内存来存储，就避免了大量的指针结构，节省了内存。另外，ziplist也使用了动态分配内存的方法，也一定程度上避免了内存的浪费。下图（此图来自书本）是内存的每块代表的含义：

压缩表在Redis中的应用只存在于hash和list结构的实现中，为了在存储时节省内存。

在Redis 中，这几个数据结构算比较核心的了，大部分的功能需求都可以通过这几个中的一个或多个实现。

推荐一本非常不错的讲解Redis源码的书籍：黄健宏先生的《Redis 的设计与实现》，也是翻译本，在中国算比较核心的讲解Redis实现的书籍了（好像也没有其他的）。

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

特此声明：本文非本人所原创，是转载他人文章并总结整合方便自己学习的笔记！！！

Redis存储结构

下面以redis3.2的正式版源码分析集中存储机构：

猜你喜欢