rodert单排学习redis进阶【青铜】

Mr.Wang大约 18 分钟

rodert单排学习redis进阶【青铜】

redis之青铜

@[toc]

前言

声明：参考来源互联网，有任何争议可以留言。站在前人的肩上，我们才能看的更远。

本教程纯手打，致力于最实用教程，不需要什么奖励，只希望多多转发支持。欢迎来我公众号，希望可以结识你，也可以催更，微信搜索：JavaPub

有任何问题都可以来谈谈！

本篇继续学习 Redis ,上一篇 rodert单排学习redis入门【黑铁】对 Redis **安装和常用数据**结构做了梳理，如果没看可以先回去看完再继续本篇~

上一篇都是对一些 redis 基本数据类型 api 的讲解，本篇是数据类型底层实现，主要内容有：

为什么使用Redis
Redis数据结构解析
SDS简单动态字符串
哈希表
跳跃表
整数集合
压缩列表
Redis中数据结构的对象
...

1.再谈Redis

Redis 是什么？官话来说就是：

Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker.

Redis 是一个开源的、基于内存的数据结构存储器，可以用作数据库、缓存和消息中间件。

如果想尝试 Redis 命令又懒得安装，可以使用这个 http://try.redis.io/ 网站。

2.为什么要用Redis

上一篇咱们有一定了解

Redis 是**基于内存**，常用作缓存的一种技术，并且 Redis 存储的方式是以 key-value 形式。

那我们为什么不用 Java Map？

Java Map是**本地缓存**的，最主要的特点是轻量以及快速，生命周期随着jvm的销毁而结束，并且在多实例的情况下，每个实例都需要各自保存一份缓存，缓存不具有一致性。
JVM内存太大容易挂掉，还有各种**过期机制、存储结构**需要自己手动来写
Redis 会定期把缓存保存到硬盘，重启恢复数据，丰富的数据结构，缓存机制等实用功能。

3.为什么要使用缓存？

高并发，高可用这是现在互联网经常提到的一个词。在程序出现大量请求是就会出现**性能问题，一般性能问题第一道就是数据库扛不住了**，数据库的读写会有磁盘操作，而磁盘的速度相对内存来说慢很多。

所有我们在中间加一道缓存：

4.Redis数据结构

4.1.SDS简单动态字符串

4.1.1.SDS简单动态字符串

Redis 是由C语言编写的。

我们现在知道 Redis 所有键都是字符串，值有字符串（string）、散列（hash）、列表（list）、集合（set）和有序集合（sorted set）这五种类型的键的底层实现数据结构。

Redis 没有直接使用 C 语言传统的字符串表示（以空字符结尾的字符数组，以下简称 C 字符串），而是自己构建了一种名为简单动态字符串（simple dynamic string，SDS）的抽象类型，并将 SDS 用作 Redis 的默认字符串表示。

Redis 使用 sds.h/sdshdr 结构表示一个 SDS 值：

struct sdshdr {

    // 记录 buf 数组中已使用字节的数量
    // 等于 SDS 所保存字符串的长度
    int len;

    // 记录 buf 数组中未使用字节的数量
    int free;

    // 字节数组，用于保存字符串
    char buf[];

};

上图是 SDS 示例，以空字符结尾 '\0'。遵循空字符结尾这一惯例的好处是， SDS 可以直接重用一部分 C 字符串函数库里面的函数。

举个例子，如果我们有一个指向图 2-1 所示 SDS 的指针 s ，那么我们可以直接使用 stdio.h/printf 函数，通过执行以下语句：

printf("%s", s->buf);

来打印出 SDS 保存的字符串值 "Redis" ，而无须为 SDS 编写专门的打印函数。

4.1.2.SDS简单动态字符串好处

sdshdr数据结构中用len属性记录了字符串的长度。那么获取字符串的长度时，时间复杂度只需要 O(1)。常数复杂度获取字符串长度。
SDS不会发生溢出的问题，如果修改SDS时，空间不足。先会扩展空间，再进行修改！(内部实现了动态扩展机制)。杜绝缓冲区溢出。
SDS可以**减少内存分配的次数(空间预分配机制)。在扩展空间时，除了分配修改时所必要的空间，还会分配额外的空闲空间(free 属性)。减少修改字符串长度时所需的内存重分配次数**。
SDS是**二进制安全**的，SDS 以二进制的方式来处理SDS存放在buf数组里的数据。
可以使用一部分 <string.h> 库中的函数。兼容部分 C 字符串函数。

4.2.Redis 链表和链表节点

Java 学习者对链表应该都很熟悉，链表是 Java 中一种典型且常用的数据构。

每个**链表节点**使用一个 adlist.h/listNode 结构来表示：

typedef struct listNode {

    // 前置节点
    struct listNode *prev;

    // 后置节点
    struct listNode *next;

    // 节点的值
    void *value;

} listNode;

使用listNode是可以组成链表了，Redis中**使用list结构来持有链表**：

typedef struct list {

    // 表头节点
    listNode *head;

    // 表尾节点
    listNode *tail;

    // 链表所包含的节点数量
    unsigned long len;

    // 节点值复制函数
    void *(*dup)(void *ptr);

    // 节点值释放函数
    void (*free)(void *ptr);

    // 节点值对比函数
    int (*match)(void *ptr, void *key);

} list;

由一个 list 结构和三个 listNode 结构组成的链表：

4.2.2.Redis 链表重点

链表被广泛用于实现 Redis 的各种功能，比如列表键，发布与订阅，慢查询，监视器，等等。
每个链表节点由一个 listNode 结构来表示，每个节点都有一个指向前置节点和后置节点的指针，所以 Redis 的链表实现是双端链表。
每个链表使用一个 list 结构来表示，这个结构带有表头节点指针、表尾节点指针、以及链表长度等信息。
因为链表表头节点的前置节点和表尾节点的后置节点都指向 NULL ，所以 Redis 的链表实现是无环链表。
通过为链表设置不同的类型特定函数， Redis 的链表可以用于保存各种不同类型的值。

4.3.Redis 字典

4.3.1.哈希表

字典是 Redis 中的一个概念，Redis 的字典使用哈希表作为底层实现。一个哈希表里面可以有多个哈希表节点，而每个哈希表节点就保存了字典中的一个键值对。

空哈希表 Redis 字典所使用的哈希表由 dict.h/dictht 结构定义：

typedef struct dictht {

    // 哈希表数组
    dictEntry **table;

    // 哈希表大小
    unsigned long size;

    // 哈希表大小掩码，用于计算索引值
    // 总是等于 size - 1
    unsigned long sizemask;

    // 该哈希表已有节点的数量
    unsigned long used;

} dictht;

哈希表节点 哈希表节点使用 dictEntry 结构表示，每个 dictEntry 结构都保存着一个键值对：

typedef struct dictEntry {

    // 键
    void *key;

    // 值
    union {
        void *val; 
        uint64_t u64; //uint64_t整数
        int64_t s64; //int64_t整数
    } v;

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

} dictEntry;

有没有注意到，上图有个冲突，俩个键在同一个节点，这就是 Redis 解决键冲突 ，Redis 的哈希表使用链地址法（separate chaining）来解决键冲突：每个哈希表节点都有一个 next 指针，多个哈希表节点可以用 next 指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表连接起来，这就解决了键冲突的问题。

字典 Redis 中的字典由 dict.h/dict 结构表示：

typedef struct dict {

    // 类型特定函数
    dictType *type;

    // 私有数据
    void *privdata;

    // 哈希表
    dictht ht[2];

    // rehash 索引
    // 当 rehash 不在进行时，值为 -1
    int rehashidx; /* rehashing not in progress if rehashidx == -1 */

} dict;

------------------分割线---------------------------

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;

ht 属性是一个包含两个项的数组，数组中的每个项都是一个 dictht 哈希表，一般情况下，字典只使用 ht[0] 哈希表， ht[1] 哈希表只会在对 ht[0] 哈希表进行 rehash 时使用。

4.3.2.Redis rehash(重新散列)

随着操作的不断执行，哈希表保存的键值对会逐渐地增多或者减少，为了让哈希表的**负载因子**（load factor）维持在一个合理的范围之内，当哈希表保存的键值对数量太多或者太少时，程序需要对哈希表的大小进行相应的扩展或者收缩。

在对哈希表进行扩展或者收缩操作时，reash 过程并不是一次性地完成的，而是**渐进式**地完成的。

以下是哈希表渐进式 rehash 的详细步骤：

为 ht[1] 分配空间， 让字典同时持有 ht[0] 和 ht[1] 两个哈希表。
在字典中维持一个索引计数器变量 rehashidx ， 并将它的值设置为 0 ， 表示 rehash 工作正式开始。
在 rehash 进行期间， 每次对字典执行添加、删除、查找或者更新操作时， 程序除了执行指定的操作以外， 还会顺带将 ht[0] 哈希表在 rehashidx 索引上的所有键值对 rehash 到 ht[1] ， 当 rehash 工作完成之后， 程序将 rehashidx 属性的值增一。
随着字典操作的不断执行， 最终在某个时间点上， ht[0] 的所有键值对都会被 rehash 至 ht[1] ， 这时程序将 rehashidx 属性的值设为 -1 ， 表示 rehash 操作已完成。

4.3.3.重点

字典被广泛用于实现 Redis 的各种功能，其中包括数据库和哈希键。
Redis 中的字典使用哈希表作为底层实现，每个字典带有两个哈希表，一个用于平时使用，另一个仅在进行 rehash 时使用。
当字典被用作数据库的底层实现，或者哈希键的底层实现时， Redis 使用 MurmurHash2 算法来计算键的哈希值。
哈希表使用链地址法来解决键冲突，被分配到同一个索引上的多个键值对会连接成一个单向链表。
在对哈希表进行扩展或者收缩操作时，程序需要将现有哈希表包含的所有键值对 rehash 到新哈希表里面，并且这个 rehash 过程并不是一次性地完成的，而是渐进式地完成的。

4.4.跳跃表

4.4.1.跳跃表

Redis 的跳跃表由 redis.h/zskiplistNode 和 redis.h/zskiplist 两个结构定义，其中 zskiplistNode 结构用于表示跳跃表节点，而 zskiplist 结构则用于保存跳跃表节点的相关信息，比如节点的数量，以及指向**表头节点和表尾节点**的指针，等等。

跳跃表节点

typedef struct zskiplistNode {

    // 后退指针
    struct zskiplistNode *backward;

    // 分值
    double score;

    // 成员对象
    robj *obj;

    // 层
    struct zskiplistLevel {

        // 前进指针
        struct zskiplistNode *forward;

        // 跨度
        unsigned int span;

    } level[];

} zskiplistNode;

zskiplistNode 不同层高节点

跳跃表节点的 level 数组可以包含多个元素，每个元素都包含一个指向其他节点的指针，程序可以通过这些层来加快访问其他节点的速度，一般来说， 层的数量越多，访问其他节点的**速度就越快**。

看到这里，如果还有疑惑，不理解什么是跳跃表，传送一篇不错的跳跃表介绍文章：https://www.cnblogs.com/hunternet/p/11248192.html

4.4.2.重点

跳跃表是有序集合的底层实现之一，除此之外它在 Redis 中没有其他应用。
Redis 的跳跃表实现由 zskiplist 和 zskiplistNode 两个结构组成，其中 zskiplist 用于保存**跳跃表信息（比如表头节点、表尾节点、长度），而 zskiplistNode 则用于表示跳跃表节点**。
每个跳跃表节点的层高都是 1 至 32 之间的**随机数**。
在同一个跳跃表中，多个节点可以包含**相同的分值，但每个节点的成员对象必须是唯一**的。
跳跃表中的节点按照分值大小进行排序，当分值相同时，节点按照成员对象的大小进行排序。

4.5.整数集合

整数集合是**集合键(set)**的底层实现之一。
整数集合的底层实现为**数组，这个数组以有序、无重复的方式保存集合元素，在有需要时，程序会根据新添加元素**的类型， 改变这个数组的类型。
升级操作为整数集合带来了操作上的灵活性，并且尽可能地节约了内存。
整数集合**只支持升级**操作，不支持降级操作。

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

数据结构：

typedef struct intset {

    // 编码方式
    uint32_t encoding;

    // 集合包含的元素数量
    uint32_t length;

    // 保存元素的数组
    int8_t contents[];

} intset;

4.6.压缩列表

4.6.1.前言

同整数集合一样压缩列表也不是基础数据结构，而是 Redis 自己设计的一种数据存储结构。它有点儿类似数组，通过一片**连续的内存空间**，来存储数据。不过，它跟数组不同的一点是，它允许存储的数据大小不同。

我们知道，数组要求每个元素大大小相同，如果要存储长度不同的字符串，那就需要用**最大长度**的字符串大小作为元素的大小。以最大长度为标准，就会浪费一部分存储空间。

数组的优势占用一片**连续的空间**可以很好的利用CPU缓存访问数据。如果我们想要保留这种优势，又想节省存储空间我们可以对数组进行压缩。

那就需要给每个节点增加一个 lenght 的属性。

4.6.2.Redis 压缩列表

压缩列表(zip1ist)是 Redis 列表和 Redis 哈希的底层实现之一。

当一个列表只包含少量列表项,并且每个列表项要么就是小整数值,要么就是长度比较短的字符串,那么Redis就会使用压缩列表来做列表的底层实现。
当一个哈希只包含少量键值对,比且每个键值对的键和值要么就是小整数值,要么就是长度比较短的字符串,那么Redis就会使用压缩列表来做哈希的底层实现。

参考：https://www.cnblogs.com/hunternet/p/11306690.html

表是Redis为节约内存自己设计的一种顺序型数据结构。
表被用作列表键和哈希键的底层实现之一。
压缩列表可以包含多个节点,每个节点可以保存一个字节数组或者整数值。
添加新节点到压缩列表,或者从压缩列表中删除节点,可能会引发连锁更新操作,但这种操作出现的几率并不高。

4.7.Redis的对象

4.7.1.Redis的对象

Redis 中当我们创建一个键值对时，我们至少会创建俩个对象，一个用作键(键对象)，一个用作值(值对象)。

Redis 对象结构

typedef struct redisObject {

    // 类型
    unsigned type:4;

    // 编码
    unsigned encoding:4;

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

    // ...

} robj;

Redis 内存回收

值得一提的是 redis 内存回收，因为 C 语言并不具备自动的内存回收功能，所以 Redis 在自己的对象系统中构建了一个**引用计数（reference counting）技术实现的内存回收机制，通过这一机制，程序可以通过跟踪对象的引用计数信息，在适当的时候自动释放对象并进行内存回收**。每个对象的引用计数信息由 redisObject 结构的 refcount 属性记录：

typedef struct redisObject {

    // ...

    // 引用计数
    int refcount;

    // ...

} robj;

Redis 对象共享

举个例子，假设键 A 创建了一个包含整数值 100 的字符串对象作为值对象，如果这时键 B 也要创建一个同样保存了整数值 100 的字符串对象作为值对象。

在 Redis 中，让多个键共享同一个值对象需要执行以下两个步骤：

将数据库键的值指针指向一个现有的值对象；
将被共享的值对象的引用计数增一。

目前来说， Redis 会在初始化服务器时，创建一万个字符串对象，这些对象包含了从 0 到 9999 的所有整数值，当服务器需要用到值为 0到 9999 的字符串对象时，服务器就会使用这些共享对象，而不是新创建对象。

Redis 对象的空转时长

除了前面介绍过的 type 、 encoding 、 ptr 和 refcount 四个属性之外， redisObject 结构包含的最后一个属性为 lru 属性，该属性记录了对象最后一次被命令程序访问的时间：

typedef struct redisObject {

    // ...

    unsigned lru:22;

    // ...

} robj;

4.7.2.重点

内存回收和对象的空转时长涉及到 Redis 配置文件(内存的算法 volatile-lru、allkeys-lru等其他知识点)，后面单独一篇详细讲解。

Redis 数据库中的每个键值对的键和值都是一个对象。
Redis 共有字**符串、列表、哈希、集合、有序集合**五种类型的对象，每种类型的对象至少都有两种或以上的编码方式，不同的编码可以在不同的使用场景上优化对象的使用效率。
服务器在执行某些命令之前，会先检查给定键的类型能否执行指定的命令，而检查一个键的类型就是检查键的值对象的类型。
Redis 的对象系统带有引用计数实现的**内存回收机制**，当一个对象不再被使用时，该对象所占用的内存就会被自动释放。
Redis 会共享值为 0 到 9999 的字符串对象。
对象会记录自己的最后一次被访问的时间，这个时间可以用于计算对象的**空转时间**。