Redis知识点总结及常见问题

最新推荐文章于 2024-04-17 10:54:18 发布

橘猫的天下

最新推荐文章于 2024-04-17 10:54:18 发布

阅读量292

点赞数

分类专栏： Redis

本文链接：https://blog.csdn.net/qq_23677919/article/details/105763895

版权

Redis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Redis设计与实现阅读笔记

简单动态字符串
链表
字典
跳跃表
整数集合
压缩列表
对象
数据库
RDB持久化
AOF持久化
复制
Sentinel
集群
LUA脚本
缓存穿透
缓存雪崩
缓存击穿
数据一致性

简单动态字符串

Redis没有使用传的c语言字符串表示，而是构造了一种简单动态字符串（simple dynamic string,SDS）的抽象类型，作为Redis的默认字符串表示。

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

SDS示例

通过使用SDS带来的优势

c语言字符串（获取长度需要遍历），SDS获取字符串长度所需的复杂度O(N)降低带了O(1)，确保获取字符串长度不会成为Redis的性能瓶颈。
杜绝了缓存区溢出
减少了修改字符串时带来的内存重分配次数（内存预分配、惰性空间释放）
二进制安全
兼容部分C字符串函数

C字符串	SDS
获取字符串长度的复杂度为O(N)	获取字符串长度的复杂度为O(1)
API是不安全的，可能会造成缓冲区溢出	API是安全的，不会造成缓冲区溢出
修改字符串长度N次必然需要执行N次内存重分配	修改字符串长度N次最多需要执行N次内存重分配
只能保存文本数据	可以保存文本或者二进制数据
可以使用所有<string.h>库中的函数	可以使用一部分<string.h>库中的函数

链表

链表和链表节点的实现

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

多个listNode可以通过prev和next指针组成双端链表

listNode结构就可以组成链表，但用list来持有链表的话，操作会更方便

typedef struct list{
//表头节点
listNode*head;
//表尾节点
listNode*tail;
//链表锁包含的节点数量
unsigned long len;
//节点值赋值函数，dup函数用于复制链表节点所保存的值
void *(*dup)(void *ptr);
//节点值释放函数,free函数用于释放链表节点所保存的值
void (*free)(void *ptr);
//节点值对比函数，match函数用于对比链表节点所保存的值和另一个输入值是否相等
int (*match)(void *ptr,void *key);
} list;

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

Redis的链表实现的特性可以总结如下：

双端：链表节点带有prev和next指针，获取某个节点的前置节点和后置节点的复杂度都是O(1)
无环：表头节点prev指针和表尾节点的next指针都指向NULL，对链表的访问以NULL为终点
带表头指针和表尾指针：通过list结构的head指针来对list持有的链表节点进行计数，程序获取链表的表头节点和表尾节点的复杂度为O(1)
带链表长度计数器：程序使用list结构的len属性来对list持有的链表节点进行计数，程序获取链表中节点数量的复杂度为O(1)
多态：链表节点使用void*指针来保存节点值，并且可以通过list结构的dup、free、match三个属性为节点值设置类型特定函数，所以链表可以用于保存各种不同类型的值。

字典

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

typedef struct dictht {
	// 哈希表数组
	dictEntry **table;
	// 哈希表大小
	unsigned long size;
	//哈希表大小掩码，用于计算索引值
	//总是等于size-1
	unsigned long sizemask;
	//
}

一个大小为4的空哈希表（没有包含任何键值对）

哈希表节点

typedef struct dictEntry{
	//键
	void *key
	//值
	union{
		void *val;
		uint64_t u64;
		int64_t s64;
	} v;
	//指向下个哈希表节点，形成链表
	struct dictEntry *next;
}dictEntry;

next属性指向另一个哈希表节点的指针，解决键冲突问题

字典结构

typedef struct dict{
	// 类型特定函数
	dictType *type;
	// 私有数据
	void *privdata;
	//哈希表
	dictht ht[2]
	//rehash索引
	//当rehash不在进行时，值为-1
	int trehashidx; /* rehashing not in progress if rehashidx == -1 */
}dict;

普通状态下的字典

跳跃表

跳跃表（zkiplist）是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。
时间复杂度平均O(logN)、最坏O(N)。

header:指向跳跃表的表头节点。
tail:指向跳跃表的表尾节点。
level:记录目前跳跃表内，层数最大的那个节点的层数（表头节点的层数不计算在内）。
length:记录跳跃表的长度，跳跃表目前包含节点的数量（表头节点不计算在内）。
层（level）:节点中用L1,L2,L3等字样标记节点的各个层，每个层都有两个属性：前进指针和跨度。
后退（backward）指针：节点中用BW字样标记节点的后退指针。
分值（score）:各个节点中的1.0,2.0,3.0是节点所保存的分值。
成员对象（obj）:各个节点中的o1、o2、o3是节点所保存的成员对象。

跳跃表节点

typedef struct zskiplistNode {
	//后退指针
	struct zskiplistNode *backward;
	//分值
	double score;
	//层
	struct zskiplistLevel {
		//前进指针
		struct zskiplistNode *forward;
		//跨度
		unsigned int span;
	}level[];
}zskiplistNode;

整数集合

集合键的底层实现之一

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

压缩列表

列表键和哈希键的底层实现之一

对象

以上的介绍是Redis用到的所有主要数据结构，比如简单动态字符串（SDS）、双端链表、字典、压缩列表、整数集合等等。

Redis并没有直接使用这些数据结构来实现键值对数据库，而是基于这些数据结构创建了一个对象系统，包括字符串对象、列表对象、哈希对象、集合对象、和有序集合对象这五种不同类型的对象。

Redis中的每个对象都由一个redisObject结构表示：

typedef struct redisObject {
	//类型
	unsigned type:4;
	//编码
	unsigned encoding:4;
	//指向底层实现数据结构的指针
	void *ptr;
	
	//...
}robj;

对象的类型

类型常量	对象的名称
Redis_String	字符串对象
Redis_LIST	列表对象
Redis_HASH	哈希对象
Redis_SET	集合对象
Redis_ZSET	有序集合对象

数据库

Redis服务器将所有数据库都保存在服务器状态redis.h/redisServer结构的db数组中，db数组的每一个项都是一个redis.h/RedisDb结构，每个redisDb结构代表一个数据库。

struct redisServer {
	//...
	//一个数组，保存着服务器的所有数据库
	redisDb *db;
	//服务器的数据库数量
	int dbnum;
	//...
};

dbnum属性的值有服务器配置的database选项决定，默认情况下，该选项的值为16了，所以Redis服务器默认会创建16个数据库。
服务器数据库示例
在服务器内部，客户端状态redisClient结构的db属性记录了客户端当前的目标数据库，这个属性是一个指向redisDb结构的指针：

typedef struct redisClient{
	//...
	//记录客户端当前正在使用的数据库
	redisDb *db;
	//...
}redisClient;

客户端的目标数据库为1号数据库
通过修改redisClient.db指针，让它指向服务器中的不同数据库，从而实现切换目标数据库的功能----这就是SELECT命令的实现原理。

RDB持久化

RDB持久化功能所生成的RDB文件是一个经过压缩的二进制文件，通过该文件可以还原生成RDB文件时的数据库状态。
两种redis命令用于生成RDB文件
SAVE

redis> SAVE   //等待直到RDB文件创建完毕
OK

BGSAVE

redis> BGSAVE //派生子进程，并由子进程创建RDB文件
Background saving started

创建RDB文件的实际工作有rdb.c/rdbSave函数完成

def save():
	#创建RDB文件
	rdbSave();
	
def	BGSAVE():
	#创建子进程
	pid = fork()
	if pid == 0:
		#子进程负责创建RDB文件
		rdbSave()
		#完成之后向父进程发送信号
		signal_parent()
	elif pid > 0:
	    #父进程继续处理命令请求，并通过轮询等待子进程的信号
	    handle_request_and_wait_signal()
    else:
        #处理出错情况
        handle_fork_error()

RDB
服务器载入数据方式
![服务器载入数据方式](https://img-blog.csdnimg.cn/20200525140303613.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIzNjc3OTE5,size_16,color_FFFFFF,t_70
自动间隔性保存
可以通过save选项设置多个保存条件，只要其中任意一个条件被满足，服务器就会执行BGSAVE命令。
例子：

save 900 1
save 300 10
save 60 10000

服务器在900秒之内，对数据库进行了至少1次修改。
服务器在300秒之内，对数据库进行了至少10次修改。
服务器在60秒之内，对数据库进行了至少10000次修改。

AOF持久化

AOF(Append Only File) 通过保存Redis服务器所执行的写命令来记录数据库状态。

AOF持久化的实现
分为命令追加（append）、文件写入、文件同步（sync）三个步骤。
服务器在执行命令之后，会将协议内容追加到aof_buf缓冲区的末尾
通过设置appendfsync的值来决定何时把缓冲区的内容同步到AOF文件中

appendfsync选项的值	flushAppendOnlyFile函数的行为
always	将aof_buf缓冲区中的所有内容写入并同步到AOF文件
everysec	将aof_buf缓冲区中的所有内容写入到AOF文件，如果上次同步AOF文件的时间距离现在超过一秒钟，name再次对AOF文件进行同步，并且这个同步操作是由一个线程专门负责执行的
no	将aof_buf缓冲区中的所有内容写入到AOF文件中，但并不对AOF文件进行同步，何时同步由操作系统来决定

文件的写入和同步

为了提高文件的写入效率，在现代操作系统中，当用户调用write函数，将一些数据写入到文件的时候，操作系统通常会将写入数据暂时保存在一个内存缓冲区里面，等到缓冲区的空间被填满、或者超过了指定的时限之后，才真正的将缓冲区中的数据写入到磁盘里面。
这种做法虽然提高了效率，但也会写入数据带来了安全问题，因为如果计算机发生停机，那么保存在内存缓冲区里面的写入数据将会丢失。
为此，系统提供了fsync和fdatasync两个同步函数，他们可以强制让操作系统立即将缓冲区中的数据写入到硬盘里面，从而确保写入数据的安全性。

AOF重写
AOF持久化是保存被执行的写命令，服务器运行久了，AOF文件内容越多，体积越大，可能影响服务器，并且还原数据所需时间长，所以需要对它进行重写，去掉浪费空间的冗余命令。

AOF后台重写

AOF重写会fork一个子进程来处理重写程序，父进程可以继续处理命令请求，可以避免使用锁的情况下，保证数据的安全性。
在重写期间，父进程还可以接受写入命令，如何保证数据一致性的问题。
Redis服务器设置了一个AOF重写缓冲区，这个缓冲区在服务器创建子进程之后开始使用，当Redis服务器执行完一个写命令之后，他会同时将这个写命令发送给AOF缓冲区和AOF重写缓冲区。

复制

通过执行SLAVEOF命令或者设置slaveif选项，让一个服务器去复制（replicate）另一个服务器，称被复制的服务器为主服务器（master），而对主服务器进行复制的服务器则被称为从服务器（slave）。

Sentinel

Sentinel（哨兵）是Redis的高可用性的解决方案。

集群

Redis集群是Redis提供的分布式数据库方案，集群通过分片（sharding）来进行数据共享，并提供复制和故障转移功能。

LUA脚本

Redis从2.6版本开始引入对Lua脚本的支持，通过在服务器嵌入Lua环境，Redis客户端可以使用Lua脚本，直接在服务器端原子的执行多个Redis命令。

缓存穿透

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
为了避免缓存穿透其实有很多种解决方案。下面介绍几种。

解决方案

（1）布隆过滤器

布隆过滤器是一种数据结构，垃圾网站和正常网站加起来全世界据统计也有几十亿个。网警要过滤这些垃圾网站，总不能到数据库里面一个一个去比较吧，这就可以使用布隆过滤器。假设我们存储一亿个垃圾网站地址。

可以先有一亿个二进制比特，然后网警用八个不同的随机数产生器（F1,F2, …,F8）产生八个信息指纹（f1, f2, …, f8）。接下来用一个随机数产生器 G 把这八个信息指纹映射到 1 到1亿中的八个自然数 g1, g2, …,g8。最后把这八个位置的二进制全部设置为一。过程如下：

布隆过滤器
有一天网警查到了一个可疑的网站，想判断一下是否是XX网站，首先将可疑网站通过哈希映射到1亿个比特数组上的8个点。如果8个点的其中有一个点不为1，则可以判断该元素一定不存在集合中。

那这个布隆过滤器是如何解决redis中的缓存穿透呢？很简单首先也是对所有可能查询的参数以hash形式存储，当用户想要查询的时候，使用布隆过滤器发现不在集合中，就直接丢弃，不再对持久层查询。

2、缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源；
缓存穿透

但是这种方法会存在两个问题：

如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键；
即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

缓存雪崩

1、概念

缓存雪崩是指，缓存层出现了错误，不能正常工作了。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。

2、解决方案

（1）redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。

（2）限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

（3）数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

缓存击穿

1、概念
缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

2、解决方案
缓存击穿的话，设置热点数据永远不过期。或者加上互斥锁

	/**
     * 获取数据
     * @param Key                     查询参数
     * @return data                   数据
     * @throws InterruptedException   异常
     */
    public static String getData(String Key) throws InterruptedException {
        // 从redis查询数据
        String result = getDataByKV(Key);
        // 参数校验
        if (StringUtils.isBlank(result)) {
            // 获取锁
            if (reenLock.tryLock()) {
                // 去数据库查询
                result = getDataByDB(Key);
                // 校验
                if (StringUtils.isNotBlank(result)) {
                    // 搞进缓存
                    setDataToKV(Key, result);
                }
                // !!!释放锁 正常会在finally里面释放
                reenLock.unLock();
            } else {
                // 睡一会再拿
                Thread.sleep(100L);
                result = getData(Key);
            }
        }
        return result;
    }
// 这里面的锁都是单机玩玩，分布式锁还是得靠lua脚本这样的

数据一致性

在这里插入图片描述

橘猫的天下

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis知识点总结及常见问题

数据结构：Redis没有使用传的c语言字符串表示，而是构造了一种简单动态字符串（simple dynamic string,SDS）的抽象类型，作为Redis的默认字符串表示。struct sdshdr { //记录buf数组中已使用的字节的数量 //等于SDS所保存字符串的长度 int len; //记录buf数组中未使用字节的数量 int free; //字节数组，...
复制链接

扫一扫