Redis为什么这么快--数据存储角度

      本文内容思惟导图以下：

1、简介和应用

      Redis是一个由ANSI C语言编写，性能优秀、支持网络、可持久化的K-K内存数据库，并提供多种语言的API。它经常使用的类型主要是 String、List、Hash、Set、ZSet 这5种

 

      Redis在互联网公司通常有如下应用:

• String：缓存、限流、计数器、分布式锁、分布式Session
• Hash：存储用户信息、用户主页访问量、组合查询
• List：微博关注人时间轴列表、简单队列
• Set：赞、踩、标签、好友关系
• Zset：排行榜

      再好比电商在大促销时，会用一些特殊的设计来保证系统稳定，扣减库存能够考虑以下设计：

                             

      上图中，直接在Redis中扣减库存，记录日志后经过Worker同步到数据库，在设计同步Worker时须要考虑并发处理和重复处理的问题。

经过上面的应用场景能够看出Redis是很是高效和稳定的，那Redis底层是如何实现的呢？

2、Redis的对象redisObject

     当咱们执行set hello world命令时，会有如下数据模型：

                          

• dictEntry：Redis给每一个key-value键值对分配一个dictEntry，里面有着key和val的指针，next指向下一个dictEntry造成链表，这个指针能够将多个哈希值相同的键值对连接在一块儿，由此来解决哈希冲突问题(链地址法)。
• sds：键key“hello”是以SDS（简单动态字符串）存储，后面详细介绍。
• redisObject：值val“world”存储在redisObject中。实际上，redis经常使用5中类型都是以redisObject来存储的；而redisObject中的type字段指明了Value对象的类型，ptr字段则指向对象所在的地址。

      redisObject对象很是重要，Redis对象的类型、内部编码、内存回收、共享对象等功能，都须要redisObject支持。这样设计的好处是，能够针对不一样的使用场景，对5中经常使用类型设置多种不一样的数据结构实现，从而优化对象在不一样场景下的使用效率。

      不管是dictEntry对象，仍是redisObject、SDS对象，都须要内存分配器（如jemalloc）分配内存进行存储。jemalloc做为Redis的默认内存分配器，在减少内存碎片方面作的相对比较好。好比jemalloc在64位系统中，将内存空间划分为小、大、巨大三个范围；每一个范围内又划分了许多小的内存块单位；当Redis存储数据时，会选择大小最合适的内存块进行存储。

      前面说过，Redis每一个对象由一个redisObject结构表示，它的ptr指针指向底层实现的数据结构，而数据结构由encoding属性决定。好比咱们执行如下命令获得存储“hello”对应的编码：

      redis全部的数据结构类型以下（重要，后面会用）：

3、String

      字符串对象的底层实现能够是int、raw、embstr（上面的表对应有名称介绍）。embstr编码是经过调用一次内存分配函数来分配一块连续的空间，而raw须要调用两次。

      int编码字符串对象和embstr编码字符串对象在必定条件下会转化为raw编码字符串对象。embstr：<=39字节的字符串。int：8个字节的长整型。raw：大于39个字节的字符串。

      简单动态字符串（SDS），这种结构更像C++的String或者Java的ArrayList<Character>，长度动态可变：

struct sdshdr {
    // buf 中已占用空间的长度
    int len;
    // buf 中剩余可用空间的长度
    int free;
    // 数据空间
    char buf[]; // ’\0’空字符结尾
};

•        get：sdsrange---O(n)
• 　　set：sdscpy—O(n)
• 　　create：sdsnew---O(1)
• 　　len：sdslen---O(1)

      常数复杂度获取字符串长度：由于SDS在len属性中记录了长度，因此获取一个SDS长度时间复杂度仅为O(1)。

      预空间分配：若是对一个SDS进行修改，分为一下两种状况：

• SDS长度（len的值）小于1MB，那么程序将分配和len属性一样大小的未使用空间，这时free和len属性值相同。举个例子，SDS的len将变成15字节，则程序也会分配15字节的未使用空间，SDS的buf数组的实际长度变成15+15+1=31字节（额外一个字节用户保存空字符）。
• SDS长度（len的值）大于等于1MB，程序会分配1MB的未使用空间。好比进行修改以后，SDS的len变成30MB，那么它的实际长度是30MB+1MB+1byte。

      惰性释放空间：当执行sdstrim（截取字符串）以后，SDS不会立马释放多出来的空间，若是下次再进行拼接字符串操做，且拼接的没有刚才释放的空间大，则那些未使用的空间就会排上用场。经过惰性释放空间避免了特定状况下操做字符串的内存从新分配操做。

      杜绝缓冲区溢出：使用C字符串的操做时，若是字符串长度增长（如strcat操做）而忘记从新分配内存，很容易形成缓冲区的溢出；而SDS因为记录了长度，相应的操做在可能形成缓冲区溢出时会自动从新分配内存，杜绝了缓冲区溢出。

4、List

      List对象的底层实现是quicklist（快速列表，是ziplist 压缩列表 和linkedlist 双端链表 的组合）。Redis中的列表支持两端插入和弹出，并能够得到指定位置（或范围）的元素，能够充当数组、队列、栈等。

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

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

• 　    rpush: listAddNodeHead ---O(1)
• 　　lpush: listAddNodeTail ---O(1)
• 　　push:listInsertNode ---O(1)
• 　　index : listIndex ---O(N)
• 　　pop:ListFirst/listLast ---O(1)
• 　　llen:listLength ---O(N)

4.1  linkedlist（双端链表）

      此结构比较像Java的LinkedList，有兴趣能够阅读一下源码。

     

      从图中能够看出Redis的linkedlist双端链表有如下特性：节点带有prev、next指针、head指针和tail指针，获取前置节点、后置节点、表头节点和表尾节点的复杂度都是O（1）。len属性获取节点数量也为O（1）。

与双端链表相比，压缩列表能够节省内存空间，可是进行修改或增删操做时，复杂度较高；所以当节点数量较少时，可使用压缩列表；可是节点数量多时，仍是使用双端链表划算。

4.2  ziplist（压缩列表）

      当一个列表键只包含少许列表项，且是小整数值或长度比较短的字符串时，那么redis就使用ziplist（压缩列表）来作列表键的底层实现。

             

      ziplist是Redis为了节约内存而开发的，是由一系列特殊编码的连续内存块(而不是像双端链表同样每一个节点是指针)组成的顺序型数据结构；具体结构相对比较复杂，有兴趣读者能够看 Redis 哈希结构内存模型剖析。在新版本中list链表使用 quicklist 代替了 ziplist和 linkedlist：

      quickList 是 zipList 和 linkedList 的混合体。它将 linkedList 按段切分，每一段使用 zipList 来紧凑存储，多个 zipList 之间使用双向指针串接起来。由于链表的附加空间相对过高，prev 和 next 指针就要占去 16 个字节 (64bit 系统的指针是 8 个字节)，另外每一个节点的内存都是单独分配，会加重内存的碎片化，影响内存管理效率。

      quicklist 默认的压缩深度是 0，也就是不压缩。为了支持快速的 push/pop 操做，quicklist 的首尾两个 ziplist 不压缩，此时深度就是 1。为了进一步节约空间，Redis 还会对 ziplist 进行压缩存储，使用 LZF 算法压缩。

5、Hash

      Hash对象的底层实现能够是ziplist（压缩列表）或者hashtable（字典或者也叫哈希表）。

      Hash对象只有同时知足下面两个条件时，才会使用ziplist（压缩列表）：1.哈希中元素数量小于512个；2.哈希中全部键值对的键和值字符串长度都小于64字节。

      hashtable哈希表能够实现O(1)复杂度的读写操做，所以效率很高。源码以下：

typedef struct dict {
    // 类型特定函数
    dictType *type;
     // 私有数据
    void *privdata;
     // 哈希表
    dictht ht[2];
    // rehash 索引
    // 当 rehash 不在进行时，值为 -1
    int rehashidx; /* rehashing not in progress if rehashidx == -1 */
     // 目前正在运行的安全迭代器的数量
    int iterators; /* number of iterators currently running */
 } dict;
 typedef struct dictht {
    // 哈希表数组
    dictEntry **table;
     // 哈希表大小
    unsigned long size;
    // 哈希表大小掩码，用于计算索引值
    // 老是等于 size - 1
    unsigned long sizemask;
    // 该哈希表已有节点的数量
    unsigned long used;
} dictht;
typedef struct dictEntry {
    void *key;
    union {void *val;uint64_t u64;int64_t s64;} v;
    // 指向下个哈希表节点，造成链表
    struct dictEntry *next;
 } dictEntry;
 typedef struct dictType {
     // 计算哈希值的函数
    unsigned int (*hashFunction)(const void *key);
     // 复制键的函数
    void *(*keyDup)(void *privdata, const void *key);
     // 复制值的函数
    void *(*valDup)(void *privdata, const void *obj);
     // 对比键的函数
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
    // 销毁键的函数
    void (*keyDestructor)(void *privdata, void *key);
    // 销毁值的函数
    void (*valDestructor)(void *privdata, void *obj);
} dictType;

上面源码能够简化成以下结构：

                               

      这个结构相似于JDK7之前的HashMap<String,Object>，当有两个或以上的键被分配到哈希数组的同一个索引上时，会产生哈希冲突。Redis也使用链地址法来解决键冲突。即每一个哈希表节点都有一个next指针，多个哈希表节点用next指针构成一个单项链表，链地址法就是将相同hash值的对象组织成一个链表放在hash值对应的槽位。

      Redis中的字典使用hashtable做为底层实现的话，每一个字典会带有两个哈希表，一个平时使用，另外一个仅在rehash（从新散列）时使用。随着对哈希表的操做，键会逐渐增多或减小。为了让哈希表的负载因子维持在一个合理范围内，Redis会对哈希表的大小进行扩展或收缩（rehash），也就是将ht【0】里面全部的键值对分屡次、渐进式的rehash到ht【1】里。

6、Set

Set集合对象的底层实现能够是intset（整数集合）或者hashtable（字典或者也叫哈希表）。

intset（整数集合）当一个集合只含有整数，而且元素很少时会使用intset（整数集合）做为Set集合对象的底层实现。

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

• sadd:intsetAdd---O(1)
• smembers:intsetGetO(1)---O(N)
• srem:intsetRemove---O(N)
• slen:intsetlen ---O(1)

intset底层实现为有序，无重复数组保存集合元素。 intset这个结构里的整数数组的类型能够是16位的，32位的，64位的。若是数组里全部的整数都是16位长度的，若是新加入一个32位的整数，那么整个16的数组将升级成一个32位的数组。升级能够提高intset的灵活性，又能够节约内存，但不可逆。

7.ZSet

ZSet有序集合对象底层实现能够是ziplist（压缩列表）或者skiplist（跳跃表）。

当一个有序集合的元素数量比较多或者成员是比较长的字符串时，Redis就使用skiplist（跳跃表）做为ZSet对象的底层实现。

typedef struct zskiplist {
     // 表头节点和表尾节点
    struct zskiplistNode *header, *tail;
    // 表中节点的数量
    unsigned long length;
    // 表中层数最大的节点的层数
    int level;
 } zskiplist;
typedef struct zskiplistNode {
    // 成员对象
    robj *obj;
    // 分值
    double score;
     // 后退指针
    struct zskiplistNode *backward;
    // 层
    struct zskiplistLevel {
        // 前进指针
        struct zskiplistNode *forward;
         // 跨度---前进指针所指向节点与当前节点的距离
        unsigned int span;
    } level[];
} zskiplistNode;

　　zadd---zslinsert---平均O(logN), 最坏O(N)

　　zrem---zsldelete---平均O(logN), 最坏O(N)

　　zrank--zslGetRank---平均O(logN), 最坏O(N)

    

 

skiplist的查找时间复杂度是LogN，能够和平衡二叉树至关，但实现起来又比它简单。跳跃表(skiplist)是一种有序数据结构，它经过在某个节点中维持多个指向其余节点的指针，从而达到快速访问节点的目的。

参考：

《Redis设计与实现》--黄健宏