学习参考视频：【狂神说Java】Redis

Redis

一、redis相关概述

redis属于非关系型数据库。

1.关于非关系型数据库的介绍

非关系型的数据库，也就是NoSQL（Not Only SQL）。

关系型数据库：列+行，同一个表下数据的结构是一样的。

非关系型数据库：数据存储没有固定的格式，并且可以进行横向扩展。

NoSQL泛指非关系型数据库，随着web2.0互联网的诞生，传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区，暴露出来很多难以克服的问题，NoSQL在当今大数据环境下发展的十分迅速，Redis是发展最快的。

NoSQL的特点

1. 方便扩展（数据之间没有关系，很好扩展！）
2. 大数据量高性能（Redis一秒可以写8万次，读11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高！）
3. 数据类型是多样型的！（不需要事先设计数据库，随取随用）

NoSQL的分类

2.什么是redis

​ Redis是一款内存高速缓存数据库。Redis全称为：Remote Dictionary Server （远程数据服务），使用C语言编写，Redis是一个key-value存储系统（键值存储系统），支持丰富的数据类型，如：String、list、set、zset、hash。

3.redis的应用场景

​ 众多语言都支持Redis，因为Redis交换数据快，在服务器中常用来存储一些需要频繁调取的数据，节省内存开销，也极大的提升了速度。

​ 将一些热点数据存储到Redis中，要用的时候，直接从内存取，极大的提高了速度和节约了服务器的开销。

​ 1、会话缓存（最常用）

​ 2、消息队列（支付）

​ 3、活动排行榜或计数

​ 4、发布，订阅消息（消息通知）

​ 5、商品列表，评论列表

二、五大数据类型

在介绍五大数据类型之前，我们先来了解一下关于key操作的基础命令

127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> type name
string
127.0.0.1:6379> expire name 10 #设置10s到期时间
(integer) 1
127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> exists name #10s后过期了
(integer) 0
127.0.0.1:6379> keys *   #在查看当前数据库所有的key，发现无了
(empty list or set)

String（字符串）

由于redis输入命令后面会有提示，我这里就写他的关键词了

127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"thenie"
127.0.0.1:6379> get age
"18"
127.0.0.1:6379> append name Shuai  #向指定字符串后加Shuai
(integer) 11
127.0.0.1:6379> get name
"thenieShuai"
127.0.0.1:6379> DECR age #自减
(integer) 17
127.0.0.1:6379> INCR age #自增
(integer) 18
127.0.0.1:6379> DECRBY age 5 #指定减少
(integer) 13
127.0.0.1:6379> INCRBY age 5
(integer) 18
127.0.0.1:6379> STRLEN age #返回字符串长度
(integer) 2
127.0.0.1:6379> getrange name 0 -1 #返回完整字符串
"thenieShuai"
127.0.0.1:6379> getrange name 0 6 #返回下标为0~6的字符串
"thenieS"
127.0.0.1:6379> setrange name 6 Haokan #从6的位置开始用Haokan进行覆盖
(integer) 12
127.0.0.1:6379> get name
"thenieHaokan"
127.0.0.1:6379> GETSET name kuaijieshule #返回name的值，并进行指定的修改
"thenieHaokan"
127.0.0.1:6379> GET name
"kuaijieshule"
127.0.0.1:6379> setnx name ,  #创建,失败，因为存在key为name
(integer) 0
127.0.0.1:6379> get name
"kuaijieshule"

String类似的使用场景：value除了是字符串还可以是数字，用途举例：

• 计数器
• 统计多单位的数量：uid:123666：follow 0
• 粉丝数
• 对象存储缓存

Hash（哈希）

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。

127.0.0.1:6379> HSET mymap k1 v1 #初始化一个key为mymap的集合
(integer) 1
127.0.0.1:6379> HSET mymap k2 v2
(integer) 1
127.0.0.1:6379> HMSET mymap k3 v3 k4 v4
OK
127.0.0.1:6379> HEXISTS mymap k1 #判断k1在mymap中是否存在
(integer) 1
127.0.0.1:6379> HEXISTS mymap k5
(integer) 0
127.0.0.1:6379> HGETALL mymap  #返回mymap中所有的key和value
1) "k1"
2) "v1"
3) "k2"
4) "v2"
5) "k3"
6) "v3"
7) "k4"
8) "v4"
127.0.0.1:6379> HGET mymap k1
"v1"
127.0.0.1:6379> HKEYS mymap #返回mymap中所有的key
1) "k1"
2) "k2"
3) "k3"
4) "k4"
127.0.0.1:6379> HVALS mymap
1) "v1"
2) "v2"
3) "v3"
4) "v4"
127.0.0.1:6379> HDEL mymap k2 #删除mymap中的k2
(integer) 1
127.0.0.1:6379> HKEYS mymap
1) "k1"
2) "k3"
3) "k4"
127.0.0.1:6379> HSET mymap number 10
(integer) 1
127.0.0.1:6379> hget mymap number
"10"
127.0.0.1:6379> HINCRBY mymap number 10
(integer) 20

Hash变更的数据user name age，尤其是用户信息之类的，经常变动的信息！Hash更适合于对象的存储，Sring更加适合字符串存储！

List（列表）

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）

一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

首先我们列表，可以经过规则定义将其变为队列、栈、双端队列等

正如图Redis中List是可以进行双端操作的，所以命令也就分为了LXXX和RLLL两类，有时候L也表示List例如LLEN

127.0.0.1:6379> rpush list a b c d e f  #初始化key为list的列表
(integer) 6
127.0.0.1:6379> LRANGE list 0 -1   #从左至右返回list
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"
127.0.0.1:6379> LPUSH list 1  #向左插入1
(integer) 7
127.0.0.1:6379> LRANGE list 0 -1
1) "1"
2) "a"
3) "b"
4) "c"
5) "d"
6) "e"
7) "f"
127.0.0.1:6379> RPUSH list 2  #向右插入2
(integer) 8
127.0.0.1:6379> LRANGE list 0 -1  #从左至右返回list
1) "1"
2) "a"
3) "b"
4) "c"
5) "d"
6) "e"
7) "f"
8) "2"
127.0.0.1:6379> llen list
(integer) 8
127.0.0.1:6379> LINDEX list 2 
"b"
127.0.0.1:6379> LPUSH list1 1  #初始化一个list1的列表
(integer) 1
127.0.0.1:6379> RPOPLPUSH list list1  #从list的右边弹出一个值并向list的左边插入
"2"
127.0.0.1:6379> LRANGE list1 0 -1
1) "2"
2) "1"
127.0.0.1:6379> LPOP list1
"2"
127.0.0.1:6379> LPOP list1
"1"
127.0.0.1:6379> LTRIM list 1 8
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"

小结

• list实际上是一个链表，before Node after , left, right 都可以插入值
• 如果key不存在，则创建新的链表
• 如果key存在，新增内容
• 如果移除了所有值，空链表，也代表不存在
• 在两边插入或者改动值，效率最高！修改中间元素，效率相对较低

应用：

消息排队！消息队列（Lpush Rpop）,栈（Lpush Lpop）

Set（集合）

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

127.0.0.1:6379> sadd set a b c  #初始化key为set的集合
(integer) 3
127.0.0.1:6379> sadd set1 d e f #初始化key为set1的集合
(integer) 3
127.0.0.1:6379> SMEMBERS set  #查看指定集合的全部成员
1) "b"
2) "c"
3) "a"
127.0.0.1:6379> SISMEMBER set b #判断b是否存在于集合中
(integer) 1
127.0.0.1:6379> SISMEMBER set c
(integer) 1
127.0.0.1:6379> SISMEMBER set e
(integer) 0
127.0.0.1:6379> SRANDMEMBER set 2 #随机返回两个成员
1) "b"
2) "c"
127.0.0.1:6379> SRANDMEMBER set 2
1) "a"
2) "c"
127.0.0.1:6379> SADD set d
(integer) 1
127.0.0.1:6379> SMOVE set set1 a #将set中的a移入set1中
(integer) 1
127.0.0.1:6379> SMEMBERS set
1) "b"
2) "c"
3) "d"
127.0.0.1:6379> SMEMBERS set1
1) "a"
2) "f"
3) "e"
4) "d"
127.0.0.1:6379> SREM set1 a  #删除set1中的a元素
(integer) 1
127.0.0.1:6379> SMEMBERS set1
1) "f"
2) "e"
3) "d"

ZSet（sorted set 有序集合）

不同的是每个元素都会关联一个double类型的分数（score）。redis正是通过分数来为集合中的成员进行从小到大的排序。

score相同：按字典顺序排序

有序集合的成员是唯一的,但分数(score)却可以重复。

-------------------ZADD--ZCARD--ZCOUNT--------------
127.0.0.1:6379> ZADD myzset 1 m1 2 m2 3 m3 # 向有序集合myzset中添加成员m1 score=1 以及成员m2 score=2..
(integer) 2
127.0.0.1:6379> ZCARD myzset # 获取有序集合的成员数
(integer) 2
127.0.0.1:6379> ZCOUNT myzset 0 1 # 获取score在 [0,1]区间的成员数量
(integer) 1
127.0.0.1:6379> ZCOUNT myzset 0 2
(integer) 2

----------------ZINCRBY--ZSCORE--------------------------
127.0.0.1:6379> ZINCRBY myzset 5 m2 # 将成员m2的score +5
"7"
127.0.0.1:6379> ZSCORE myzset m1 # 获取成员m1的score
"1"
127.0.0.1:6379> ZSCORE myzset m2
"7"

--------------ZRANK--ZRANGE-----------------------------------
127.0.0.1:6379> ZRANK myzset m1 # 获取成员m1的索引，索引按照score排序，score相同索引值按字典顺序顺序增加
(integer) 0
127.0.0.1:6379> ZRANK myzset m2
(integer) 2
127.0.0.1:6379> ZRANGE myzset 0 1 # 获取索引在 0~1的成员
1) "m1"
2) "m3"
127.0.0.1:6379> ZRANGE myzset 0 -1 # 获取全部成员
1) "m1"
2) "m3"
3) "m2"

#testset=>{abc,add,amaze,apple,back,java,redis} score均为0
------------------ZRANGEBYLEX---------------------------------
127.0.0.1:6379> ZRANGEBYLEX testset - + # 返回所有成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
5) "back"
6) "java"
7) "redis"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 0 3 # 分页 按索引显示查询结果的 0,1,2条记录
1) "abc"
2) "add"
3) "amaze"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 3 3 # 显示 3,4,5条记录
1) "apple"
2) "back"
3) "java"
127.0.0.1:6379> ZRANGEBYLEX testset (- [apple # 显示 (-,apple] 区间内的成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
127.0.0.1:6379> ZRANGEBYLEX testset [apple [java # 显示 [apple,java]字典区间的成员
1) "apple"
2) "back"
3) "java"

-----------------------ZRANGEBYSCORE---------------------
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 10 # 返回score在 [1,10]之间的的成员
1) "m1"
2) "m3"
3) "m2"
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 5
1) "m1"
2) "m3"

--------------------ZLEXCOUNT-----------------------------
127.0.0.1:6379> ZLEXCOUNT testset - +
(integer) 7
127.0.0.1:6379> ZLEXCOUNT testset [apple [java
(integer) 3

------------------ZREM--ZREMRANGEBYLEX--ZREMRANGBYRANK--ZREMRANGEBYSCORE--------------------------------
127.0.0.1:6379> ZREM testset abc # 移除成员abc
(integer) 1
127.0.0.1:6379> ZREMRANGEBYLEX testset [apple [java # 移除字典区间[apple,java]中的所有成员
(integer) 3
127.0.0.1:6379> ZREMRANGEBYRANK testset 0 1 # 移除排名0~1的所有成员
(integer) 2
127.0.0.1:6379> ZREMRANGEBYSCORE myzset 0 3 # 移除score在 [0,3]的成员
(integer) 2


# testset=> {abc,add,apple,amaze,back,java,redis} score均为0
# myzset=> {(m1,1),(m2,2),(m3,3),(m4,4),(m7,7),(m9,9)}
----------------ZREVRANGE--ZREVRANGEBYSCORE--ZREVRANGEBYLEX-----------
127.0.0.1:6379> ZREVRANGE myzset 0 3 # 按score递减排序，然后按索引，返回结果的 0~3
1) "m9"
2) "m7"
3) "m4"
4) "m3"
127.0.0.1:6379> ZREVRANGE myzset 2 4 # 返回排序结果的 索引的2~4
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYSCORE myzset 6 2 # 按score递减顺序 返回集合中分数在[2,6]之间的成员
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYLEX testset [java (add # 按字典倒序 返回集合中(add,java]字典区间的成员
1) "java"
2) "back"
3) "apple"
4) "amaze"

-------------------------ZREVRANK------------------------------
127.0.0.1:6379> ZREVRANK myzset m7 # 按score递减顺序，返回成员m7索引
(integer) 1
127.0.0.1:6379> ZREVRANK myzset m2
(integer) 4


# mathscore=>{(xm,90),(xh,95),(xg,87)} 小明、小红、小刚的数学成绩
# enscore=>{(xm,70),(xh,93),(xg,90)} 小明、小红、小刚的英语成绩
-------------------ZINTERSTORE--ZUNIONSTORE-----------------------------------
127.0.0.1:6379> ZINTERSTORE sumscore 2 mathscore enscore # 将mathscore enscore进行合并 结果存放到sumscore
(integer) 3
127.0.0.1:6379> ZRANGE sumscore 0 -1 withscores # 合并后的score是之前集合中所有score的和
1) "xm"
2) "160"
3) "xg"
4) "177"
5) "xh"
6) "188"

127.0.0.1:6379> ZUNIONSTORE lowestscore 2 mathscore enscore AGGREGATE MIN # 取两个集合的成员score最小值作为结果的
(integer) 3
127.0.0.1:6379> ZRANGE lowestscore 0 -1 withscores
1) "xm"
2) "70"
3) "xg"
4) "87"
5) "xh"
6) "93"

应用案例：

• set排序 存储班级成绩表 工资表排序！
• 普通消息，1.重要消息 2.带权重进行判断
• 排行榜应用实现，取Top N测试

三、事务

Redis的单条命令是保证原子性的，而Redis事务不保证原子性。

1.如何使用事务

• 开启事务（multi）

• 命令入队

• 执行事务(exec)

  开启事务后的命令不会立即执行，而是exec输入后一起执行

  127.0.0.1:6379> keys *
  (empty list or set)
  127.0.0.1:6379> MULTI  #开启
  OK
  127.0.0.1:6379> set name thenie    #命令入队
  QUEUED
  127.0.0.1:6379> set age 18
  QUEUED
  127.0.0.1:6379> get name
  QUEUED
  127.0.0.1:6379> get name
  QUEUED
  127.0.0.1:6379> get age
  QUEUED
  127.0.0.1:6379> EXEC  #结束--执行
  1) OK
  2) OK
  3) "thenie"
  4) "thenie"
  5) "18"
  

  在redis与其称作事务，不如叫批处理更为合适。

  如果在开启事务中途不想执行了，输入DISCARD放弃。

2.事务中的命令错误会怎么样

代码语法错误（编译时异常）所有的命令都不执行

127.0.0.1:6379> KEYS *
(empty list or set)
127.0.0.1:6379> MULTI  #开启
OK
127.0.0.1:6379> set name thenie
QUEUED
127.0.0.1:6379> set age 18
QUEUED
127.0.0.1:6379> setset name er   #错误的命令
(error) ERR unknown command `setset`, with args beginning with: `name`, `er`, 
127.0.0.1:6379> get name
QUEUED
127.0.0.1:6379> EXEC  #结束后全部没有执行
(error) EXECABORT Transaction discarded because of previous errors.

代码逻辑错误 (运行时异常) **其他命令可以正常执行 ** >>> 所以不保证事务原子性

127.0.0.1:6379> KEYS *
(empty list or set)
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set name thenie
QUEUED
127.0.0.1:6379> set age 18
QUEUED
127.0.0.1:6379> INCR name  #逻辑错误，最字符串进行了自增
QUEUED
127.0.0.1:6379> INCR age
QUEUED
127.0.0.1:6379> EXEC
1) OK
2) OK
3) (error) ERR value is not an integer or out of range  #第三条命令错误，但是其他命令也都执行了
4) (integer) 19

四、SpringBoot整合reids

可以看我的这篇博客SpringBoot整合reids

五、持久化——RDB

redis中的数据是缓存在内存中的，而内存中的数据是断电即失的，这就需要我们在指定时间间隔后将内存中的数据写入到硬盘中

这个过程就叫做持久化，RDB（Redis Databases）是其中的一种方式。

什么是RDB

在指定时间间隔后，将内存中的数据集快照写入数据库 ；在恢复时候，直接读取快照文件，进行数据的恢复 ；

默认情况下， Redis 将数据库快照保存在名字为 dump.rdb的二进制文件中。文件名可以在配置文件中进行自定义。

如何触发

• 触发持久化规则

  持久化规则配置在名为redis.conf配置文件中：

  

• flushall命令

  当执行此命令时，也会默认触发持久化。

  重启redis数据库后，数据复原。

• save

  使用 save 命令，会立刻对当前内存中的数据进行持久化 ,但是会阻塞，也就是不接受其他操作了；

  由于 save 命令是同步命令，会占用Redis的主进程。若Redis数据非常多时，save命令执行速度会非常慢，阻塞所有客户端的请求。

• bgsave

  bgsave 是异步进行，进行持久化的时候，redis 还可以将继续响应客户端请求 ；

  也就是fork()一个子进程去进行持久化，而主进程继续工作。

工作原理

在进行 RDB 的时候，redis 的主线程是不会做 io 操作的，主线程会 fork 一个子线程来完成该操作；

1. Redis 调用forks。同时拥有父进程和子进程。
2. 子进程将数据集写入到一个临时 RDB 文件中。
3. 当子进程完成对新 RDB 文件的写入时，Redis 用新 RDB 文件替换原来的 RDB 文件，并删除旧的 RDB 文件。

这种工作方式使得 Redis 可以从写时复制（copy-on-write）机制中获益(因为是使用子进程进行写操作，而父进程依然可以接收来自客户端的请求。)

优缺点

优点：

1. 适合大规模的数据恢复
2. 对数据的完整性要求不高

缺点：

1. 需要一定的时间间隔进行操作，如果redis意外宕机了，这个最后一次修改的数据就没有了。
2. fork进程的时候，会占用一定的内容空间。

六、持久化——AOF

什么是AOF

将我们所有的命令都记录下来，history，恢复的时候就把这个文件全部再执行一遍

以日志的形式来记录每个写的操作，将Redis执行过的所有指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

如何开启

默认是不开启的，我们需要手动配置，然后重启redis，就可以生效了！

如果要使用AOF，需要修改配置文件redis.conf：

appendonly no yes则表示启用AOF

转存文件出问题

如果这个aof文件有错位，这时候redis是启动不起来的，我需要修改这个aof文件

redis给我们提供了一个工具redis-check-aof --fix会将这个文件中出问题的命令剔除掉

优缺点

优点

1. 每一次修改都会同步，文件的完整性会更加好
2. 没秒同步一次，可能会丢失一秒的数据
3. 从不同步，效率最高

缺点

1. 相对于数据文件来说，aof远远大于rdb，修复速度比rdb慢！
2. Aof运行效率也要比rdb慢，所以我们redis默认的配置就是rdb持久化

七、redis主从复制

概念

在redis主从架构中，Master节点负责处理写请求，Slave节点只处理读请求。对于写请求少，读请求多的场景，例如电商详情页，通过这种读写分离的操作可以大幅提高并发量，通过增加redis从节点的数量可以使得redis的QPS达到10W+。

当Master结点写入数据后会同步到Slave结点，简易版架构图如下：

在一台服务器上模拟一主二从（redis）

1. 设置三个redis服务进程，并进行配置

   cp三个配置文件：

   

   #分别修改三个redis的配置文件
   --------------主（redis.conf）-------------
   #端口号
   port 6379
   #pid文件名
   pidfile /var/run/redis_6379.pid
   #日志文件名
   logfile "6379.log"
   #rdb文件名
   dbfilename dump.rdb
   --------------从（slave1.conf）-------------
   port 6380
   pidfile /var/run/redis_6380.pid
   logfile "6380.log"
   dbfilename dump6380.rdb
   --------------从（slave2.conf）-------------
   port 6381
   pidfile /var/run/redis_6381.pid
   logfile "6381.log"
   dbfilename dump6381.rdb
   

   启动服务成功：

   

2. 建立联系

   默认情况下每台redis都是主机点，所以我们只用配置从机就好了

   使用SLAVEOF host port就可以为从机配置主机了。

   配置成功并用info replication查看主从状态信息：

   

   使用规则

   • 从机只能进行读操作，主机可以读但是多用于写

   • 当主机断电宕机后，默认情况下从机的角色不会发生变化 ，集群中只是失去了写操作，当主机恢复以后，又会连接上从机恢复原状。

   • 当从机断电宕机后，若不是使用配置文件配置的从机，再次启动后作为主机是无法获取之前主机的数据的，若此时重新配置称为从机，又可以获取到主机的所有数据。这里就要提到一个同步原理。

   • 第二条中提到，默认情况下，主机故障后，不会出现新的主机，有两种方式可以产生新的主机：

     • 从机手动执行命令slaveof no one,这样执行以后从机会独立出来成为一个主机
     • 使用哨兵模式（自动选举）

八、哨兵模式

当主服务器宕机后，如果手动切换主服务器显然是不太现实的，更多时候采用哨兵模式。

概述

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

这里哨兵的作用：

• 通过发送命令，监控redis，让其返回运行状态（包括主服务器和从服务器）
• 当哨兵检测到master宕机后，会自动将一台slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

故障切换（failover）的过程

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。这样对于客户端而言，一切都是透明的。

九、缓存穿透与雪崩

缓存穿透

概念

在默认情况下，用户请求数据时，会先去缓存中去查找，未命中再去数据库中查找。但如果访问量过大，并且缓存未命中，这时都会转移到数据库中，导致压力过大，就可能导致数据库崩溃。网络安全中也有人恶意使用这种手段进行攻击被称为洪水攻击。

解决方案

布隆过滤器

顾名思义，布隆，在前方举起一个盾牌。

最所有可能查询的参数进行Hash存储，以便快速判断是否有该数据；在控制层进行拦截校验，如果不存在直接返回。

缓存空对象

若某次请求在缓存和数据库中没有找到，就在缓存中放一个空对象，便于后续处理。

这样做有一个缺陷：存储空对象也需要空间，大量的空对象会耗费一定的空间，存储效率并不高。解决这个缺陷的方式就是设置较短过期时间；

即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

缓存击穿

概念

相较于缓存穿透，缓存击穿目的性更强，当某个key在缓存中过期，同时有多个请求同时访问此key，这些请求都会击穿到DB中，造成瞬时DB请求量大、压力骤增。这就是缓存被击穿，只是针对其中某个key的缓存不可用而导致击穿，但是其他的key依然可以使用缓存响应。

比如热搜排行上，一个热点新闻被同时大量访问就可能导致缓存击穿。

解决方案

1. 设置热点数据永不过期

   这样就不会出现热点数据过期的情况，但是这样会占用空间，一旦热点数据过多占用空间就会更多。当redis内存空间满的时候也会清理部分数据。

2. 加互斥锁（分布式锁）

   在访问key之前，采用SETNX（set if not exists）来设置另一个短期key来锁住当前key的访问，访问结束再删除该短期key。保证同时刻只有一个线程访问。这样对锁的要求就十分高。

缓存雪崩

概念

大量的key设置了相同的过期时间，导致在缓存在同一时刻全部失效，造成瞬时DB请求量大、压力骤增，引起雪崩。

解决方案

• redis高可用

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

• 限流降级

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

• 数据预热

  数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
  对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

如果文章对您有帮助，还请赏个赞，加个关~~