Redis面试题总结

怼烎@ 2022-12-08 15:43 162阅读 0赞

# 一、Redis 简介 #

简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来支持不同的业务场景。除此之外，redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。

# 二、为什么要用 Redis,为什么要用缓存 #

主要从“高性能”和“高并发”这两点来看待这个问题。

## 1、高性能 ##

假如用户第一次访问数据库中的某些数据。这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！

## 2、高并发 ##

直接操作缓存能够承受的请求是远远大于直接访问数据库的，所以我们可以考虑把数据库中的部分数据转移到缓存中去，这样用户的一部分请求会直接到缓存这里而不用经过数据库。  
为什么要用 redis 而不用 map/guava 做缓存?  
缓存分为本地缓存和分布式缓存。以 Java 为例，使用自带的 map 或者 guava 实现的是本地缓存，最主要的特点是轻量以及快速，生命周期随着 jvm 的销毁而结束，并且在多实例的情况下，每个实例都需要各自保存一份缓存，缓存不具有一致性。

使用 redis 或 memcached 之类的称为分布式缓存，在多实例的情况下，各实例共用一份缓存数据，缓存具有一致性。缺点是需要保持 redis 或 memcached服务的高可用，整个程序架构上较为复杂。

# 三、Redis 的线程模型 #

redis 内部使用**文件事件处理器** file event handler，**这个文件事件处理器是单线程的，所以 redis 才叫做单线程的模型**。它采用 IO 多路复用机制同时监听多个 socket，根据 socket 上的事件来选择对应的事件处理器进行处理。

单线程指的是执行 Redis 命令的**核心模块是单线程的**，而不是整个 Redis 实例就一个线程，Redis 其他模块还有各自模块的线程的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center]

> Redis基于Reactor模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。  
> 因为文件事件分派器队列的消费是单线程的，所以Redis才叫单线程模型。

文件事件处理器的结构包含 4 个部分：  
1、多个 socket  
2、IO 多路复用程序  
3、文件事件分派器  
4、事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）

多个 socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将 socket 产生的事件放入队列中排队，事件分派器每次从队列中取出一个事件，把该事件交给对应的事件处理器进行处理。

**Redis 6.0 网络处理多线程**  
指的是在网络 IO 处理方面上了多线程，如网络数据的读写和协议解析等，需要注意的是，执行命令的核心模块还是单线程的。

# 四、redis 和 memcached 的区别 #

1、redis支持更丰富的数据类型（支持更复杂的应用场景）：Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。memcache支持简单的数据类型，String。

2、Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用,而Memecache把数据全部存在内存之中。

3、集群模式：memcached没有原生的集群模式，需要依靠客户端来实现往集群中分片写入数据；但是 redis 目前是原生支持 cluster 模式。

4、Memcached是多线程，非阻塞IO复用的网络模型；Redis使用单线程的多路 IO 复用模型。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 1]

# 五、Redis 常见数据结构以及使用场景分析 #

**1、String**

常用命令: set,get,decr,incr,mget 等

String数据结构是简单的key-value类型，**value其实不仅可以是String，也可以是数字**。  
常规key-value缓存应用；  
常规计数：微博数，粉丝数等。

**2、Hash**  
常用命令： hget,hset,hgetall 等。

**hash 是一个 string 类型的 field 和 value 的映射表**，hash 特别适合用于**存储对象**，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以 hash 数据结构来存储用户信息，商品信息等等。比如下面我就用 hash 类型存放了我本人的一些信息：

key=JavaUser293847
    value={ 
      “id”: 1,
      “name”: “SB110”,
      “age”: 22,
      “location”: “Wunan,Changsha”
    }

**3、List**  
常用命令: lpush,rpush,lpop,rpop,lrange等

**list 就是链表**，Redis list 的应用场景非常多，也是Redis最重要的数据结构之一，比如微博的关注列表，粉丝列表，消息列表等功能都可以用Redis的 list 结构来实现。

Redis list 的实现为一个**双向链表**，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销。

另外可以通过 **lrange** 命令，就是从某个元素开始读取多少个元素，可以基于 list 实现分页查询，这个很棒的一个功能，基于 redis 实现简单的高性能分页，可以做类似微博那种下拉不断分页的东西（一页一页的往下走），性能高。

**4、Set**

常用命令：sadd,spop,smembers,sunion 等

set 对外提供的功能与list类似是一个**列表**的功能，特殊之处在于 set 是可以**自动排重**的。

当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。可以基于 set 轻易实现交集、并集、差集的操作。

比如：在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis可以非常方便的实现如共同关注、共同粉丝、共同喜好等功能。这个过程也就是求交集的过程，具体命令如下：

sinterstore key1 key2 key3     将交集存在key1内

**5、Sorted Set**

常用命令： zadd,zrange,zrem,zcard等

和set相比，sorted set增加了一个**权重参数score**，**使得集合中的元素能够按score进行有序排列。**

举例： 在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息，适合使用 Redis 中的 Sorted Set 结构进行存储。

# 六、Redis 设置过期时间 #

Redis中有个设置时间过期的功能，即对存储在 redis 数据库中的值可以设置一个过期时间。作为一个缓存数据库，这是非常实用的。如我们一般项目中的 token 或者一些登录信息，尤其是短信验证码都是有时间限制的，按照传统的数据库处理方式，一般都是自己判断过期，这样无疑会严重影响项目性能。

我们 set key 的时候，都可以给一个 expire time，就是过期时间，通过过期时间我们可以指定这个 key 可以存活的时间。

如果假设你设置了一批 key 只能存活1个小时，那么接下来1小时后，redis是怎么对这批key进行删除的？

## 定时删除 ##

在设置key的过期时间的同时，为该key创建一个定时器，让定时器在key的过期时间来临时，对key进行删除  
**优点：**  
保证内存被尽快释放  
**缺点：**  
若过期key很多，删除这些key会占用很多的CPU时间，在CPU时间紧张的情况下，CPU不能把所有的时间用来做要紧的事儿，还需要去花时间删除这些key  
定时器的创建耗时，若为每一个设置过期时间的key创建一个定时器（将会有大量的定时器产生），性能影响严重

## 惰性删除 ##

key过期的时候不删除，每次通过key获取值的时候去检查是否过期，若过期，则删除，返回null。  
**优点：**  
删除操作只发生在通过key取值的时候发生，而且只删除当前key，所以对CPU时间的占用是比较少的，而且此时的删除是已经到了非做不可的地步（如果此时还不删除的话，我们就会获取到了已经过期的key了）  
**缺点：**  
若大量的key在超出超时时间后，很久一段时间内，都没有被获取过，那么可能发生内存泄露（无用的垃圾占用了大量的内存）

## 定期删除 ##

每隔一段时间执行一次删除过期key操作  
**优点：**  
通过限制删除操作的时长和频率，来减少删除操作对CPU时间的占用–处理"定时删除"的缺点  
定期删除过期key–处理"懒汉式删除"的缺点  
**缺点：**  
在内存友好方面，不如"定时删除"（会造成一定的内存占用，但是没有懒汉式那么占用内存）  
在CPU时间友好方面，不如"懒汉式删除"（会定期的去进行比较和删除操作，cpu方面不如懒汉式，但是比定时好）  
**难点：**  
合理设置删除操作的执行时长（每次删除执行多长时间）和执行频率（每隔多长时间做一次删除）（这个要根据服务器运行情况来定了），每次执行时间太长，或者执行频率太高对cpu都是一种压力。  
每次进行定期删除操作执行之后，需要记录遍历循环到了哪个标志位，以便下一次定期时间来时，从上次位置开始进行循环遍历。

但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？

# 七、Redis内存满了怎么办？Redis 内存淘汰机制 #

1、通过配置文件配置  
通过在Redis安装目录下面的redis.conf配置文件中添加以下配置设置内存大小

//设置Redis最大占用内存大小为100M
    maxmemory 100mb

redis的配置文件不一定使用的是安装目录下面的redis.conf文件，启动redis服务的时候是可以传一个参数指定redis的配置文件的  
2、通过命令修改  
Redis支持运行时通过命令动态修改内存大小

//设置Redis最大占用内存大小为100M
    127.0.0.1:6379> config set maxmemory 100mb
    //获取设置的Redis能使用的最大内存大小
    127.0.0.1:6379> config get maxmemory

如果不设置最大内存大小或者设置最大内存大小为0，在64位操作系统下不限制内存大小，在32位操作系统下最多使用3GB内存。

redis 内存淘汰机制(MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据?)  
**redis 提供 6种数据淘汰策略**：

**volatile-lru**：从已设置过期时间的数据集（server.db\[i\].expires）中挑选最近最少使用的数据淘汰  
**volatile-ttl**：从已设置过期时间的数据集（server.db\[i\].expires）中挑选将要过期的数据淘汰  
**volatile-random**：从已设置过期时间的数据集（server.db\[i\].expires）中任意选择数据淘汰  
**allkeys-lru**：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key（这个是最常用的）  
**allkeys-random**：从数据集（server.db\[i\].dict）中任意选择数据淘汰  
**no-eviction**：禁止驱逐数据，也就是说当内存不足以容纳新写入数据时，新写入操作会报错。这个应该没人使用吧！  
4.0版本后增加以下两种：  
**volatile-lfu**：从已设置过期时间的数据集(server.db\[i\].expires)中挑选最不经常使用的数据淘汰  
**allkeys-lfu**：当内存不足以容纳新写入数据时，在键空间中，移除最不经常使用的key

# 八、Redis到底有多快 #

Redis采用的是**基于内存**的采用的是**单进程单线程模型的 KV 数据库，由C语言编写**，官方提供的数据是可以达到**100000**\+的**QPS**（每秒内查询次数）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 2]  
**横轴是连接数，纵轴是QPS**。

# 九、Redis为什么这么快 #

1、完全**基于内存**，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)；

2、**数据结构简单**，对数据操作也简单，Redis中的数据结构是专门进行设计的；

3、**采用单线程**，避免了不必要的**上下文切换和竞争条件**，也不存在多进程或者多线程导致的切换而消耗 CPU，**不用去考虑各种锁的问题**，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；

4、**使用多路I/O复用模型，非阻塞IO**；

5、使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，**Redis直接自己构建了VM 机制** ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；

## 多路 I/O 复用模型 ##

多路I/O复用模型是利用 select、poll、epoll 可以**同时监察多个流的 I/O 事件**的能力，在**空闲**的时候，会把**当前线程阻塞掉**，当有一个或多个流有 I/O 事件时，就**从阻塞态中唤醒，于是程序就会轮询一遍所有的流**（epoll 是只轮询那些真正发出了事件的流），并且**只依次顺序的处理就绪的流**，这种做法就避免了大量的无用操作。

这里“**多路**”指的是多个网络连接，“**复用**”指的是复用同一个线程。采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求（尽量减少网络 IO 的时间消耗），且 Redis 在内存中操作数据的速度非常快，也就是说内存内的操作不会成为影响Redis性能的瓶颈，主要由以上几点造就了 Redis 具有很高的吞吐量。

# 十、redis 持久化机制 #

Redis不同于Memcached的很重一点就是，Redis支持持久化，而且支持两种不同的持久化操作。Redis的一种持久化方式叫快照（snapshotting,**RDB**），另一种方式是只追加文件（append-only file,**AOF**）。

## 1、快照（snapshotting）持久化（RDB） ##

Redis可以通过创建快照来获得存储在内存里面的数据在某个时间点上的副本。Redis创建快照之后，可以对快照进行备份，可以将快照复制到其他服务器从而创建具有相同数据的服务器副本（Redis主从结构，主要用来提高Redis性能），还可以将快照留在原地以便重启服务器的时候使用。

快照持久化是Redis默认采用的持久化方式，在redis.conf配置文件中默认有此下配置：

save 900 1           #在900秒(15分钟)之后，如果至少有1个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
    
    save 300 10          #在300秒(5分钟)之后，如果至少有10个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
    
    save 60 10000        #在60秒(1分钟)之后，如果至少有10000个key发生变化，Redis就会自动触发BGSAVE命令创建快照。

## 2、AOF（append-only file）持久化 ##

与快照持久化相比，AOF持久化 的实时性更好，因此已成为主流的持久化方案。默认情况下Redis没有开启AOF（append only file）方式的持久化，可以通过appendonly参数开启：

appendonly yes

开启AOF持久化后每执行一条会更改Redis中的数据的命令，Redis就会将该命令写入硬盘中的AOF文件。AOF文件的保存位置和RDB文件的位置相同，都是通过dir参数设置的，默认的文件名是appendonly.aof。

在Redis的配置文件中存在三种不同的 AOF 持久化方式，它们分别是：

appendfsync always    #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度
    appendfsync everysec  #每秒钟同步一次，显示地将多个写命令同步到硬盘
    appendfsync no        #让操作系统决定何时进行同步

为了兼顾数据和写入性能，用户可以考虑 appendfsync everysec选项 ，让Redis每秒同步一次AOF文件，Redis性能几乎没受到任何影响。而且这样即使出现系统崩溃，用户最多只会丢失一秒之内产生的数据。当硬盘忙于执行写入操作的时候，Redis还会优雅的放慢自己的速度以便适应硬盘的最大写入速度。

# 十一、Redis 4.0 对于持久化机制的优化 #

Redis 4.0 开始支持 RDB 和 AOF 的混合持久化（默认关闭，可以通过配置项 aof-use-rdb-preamble 开启）。

如果把混合持久化打开，AOF 重写的时候就直接把 RDB 的内容写到 AOF 文件开头。这样做的好处是可以结合 RDB 和 AOF 的优点, 快速加载同时避免丢失过多的数据。当然缺点也是有的， AOF 里面的 RDB 部分是压缩格式不再是 AOF 格式，可读性较差。

AOF 重写

AOF重写可以产生一个新的AOF文件，这个新的AOF文件和原有的AOF文件所保存的数据库状态一样，但体积更小。

AOF重写是一个有歧义的名字，该功能是通过读取数据库中的键值对来实现的，程序无须对现有AOF文件进行任何读入、分析或者写入操作。

在执行 BGREWRITEAOF 命令时，Redis 服务器会维护一个 AOF 重写缓冲区，该缓冲区会在子进程创建新AOF文件期间，记录服务器执行的所有写命令。当子进程完成创建新AOF文件的工作之后，服务器会将重写缓冲区中的所有内容追加到新AOF文件的末尾，使得新旧两个AOF文件所保存的数据库状态一致。最后，服务器用新的AOF文件替换旧的AOF文件，以此来完成AOF文件重写操作

# 十二、Redis 事务 #

Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。事务提供了一种将多个命令请求打包，然后一次性、按顺序地执行多个命令的机制，并且在事务执行期间，服务器不会中断事务而改去执行其他客户端的命令请求，它会将事务中的所有命令都执行完毕，然后才去处理其他客户端的命令请求。

在传统的关系式数据库中，常常用 ACID 性质来检验事务功能的可靠性和安全性。在 Redis 中，事务总是具有**原子性**（Atomicity）、**一致性**（Consistency）和**隔离性**（Isolation），并且当 Redis 运行在某种特定的持久化模式下时，事务也具有**持久性**（Durability）。

# 十三、缓存雪崩、穿透、击穿、降级问题及解决方案 #

## 1、缓存雪崩 ##

**缓存同一时间大面积的失效，后面的请求都会落到数据库上**，造成数据库短时间内承受大量请求而崩掉。

解决办法：  
1、在可接受的时间范围内随机设置key的过期时间，分散key的过期时间，以防止大量的key在同一时刻过期；  
2、对于一定要在固定时间让key失效的场景(例如每日12点准时更新所有最新排名)，可以在固定的失效时间时在接口服务端设置随机延时，将请求的时间打散，让一部分查询先将数据缓存起来；  
3、延长热点key的过期时间或者设置永不过期，这一点和缓存击穿中的方案一样；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 3]

## 2、缓存穿透 ##

一般是黑客故意去**请求缓存中不存在的数据**，导致**所有的请求都落到数据库上**，造成数据库短时间内承受大量请求而崩掉。

**解决方案：**  
1、在接口访问层对用户做校验，如接口传参、登陆状态、n秒内访问接口的次数；  
2、将key设置为空，但是浪费空间；  
3、利用布隆过滤器，将数据库层有的数据key存储在位数组中，以判断访问的key在底层数据库中是否存在；

基于布隆过滤器，我们可以先将数据库中数据的key存储在布隆过滤器的位数组中，每次客户端查询数据时先访问Redis：

如果Redis内不存在该数据，则通过布隆过滤器判断数据是否在底层数据库内；  
如果布隆过滤器告诉我们该key在底层库内不存在，则直接返回null给客户端即可，避免了查询底层数据库的动作；  
如果布隆过滤器告诉我们该key极有可能在底层数据库内存在，那么将查询下推到底层数据库即可；

## 3、缓存击穿 ##

缓存击穿和缓存穿透从名词上可能很难区分开来，它们的区别是：**穿透表示底层数据库没有数据且缓存内也没有数据**，**击穿表示底层数据库有数据而缓存内没有数据**。

当热点数据key失效或者缓存中并没有该数据，大量访问同时请求这个数据，就会将查询下沉到数据库层，此时数据库层的负载压力会骤增，我们称这种现象为"缓存击穿"。

**解决方案**：

1、延长热点key的过期时间或者设置永不过期，如排行榜，首页等一定会有高并发的接口；

2、利用互斥锁保证同一时刻只有一个客户端可以查询底层数据库的这个数据，一旦查到数据就缓存至Redis内，避免其他大量请求同时穿过Redis访问底层数据库；

在使用互斥锁的时候需要**避免出现死锁或者锁过期**的情况：

使用lua脚本或事务将获取锁和设置过期时间作为一个原子性操作(如：set kk vv nx px 30000)，以避免出现某个客户端获取锁之后宕机导致的锁不被释放造成死锁现象；  
另起一个线程监控获取锁的线程的查询状态，快到锁过期时间时还没查询结束则延长锁的过期时间，避免多次查询多次锁过期造成计算资源的浪费；

## 4、缓存预热 ##

缓存预热如字面意思，当系统上线时，缓存内还没有数据，如果直接提供给用户使用，每个请求都会穿过缓存去访问底层数据库，如果并发大的话，很有可能在上线当天就会宕机，因此我们需要**在上线前先将数据库内的热点数据缓存至Redis内再提供出去使用**，这种操作就成为"缓存预热"。

缓存预热的实现方式有很多，比较通用的方式是**写个批任务，在启动项目时或定时去触发将底层数据库内的热点数据加载到缓存内**。

## 5、缓存更新 ##

缓存服务（Redis）和数据服务（底层数据库）是相互独立且异构的系统，在更新缓存或更新数据的时候无法做到原子性的同时更新两边的数据，因此在并发读写或第二步操作异常时会遇到各种数据不一致的问题。

第二步操作异常：缓存和数据的操作顺序中，第二个动作报错。如数据库被更新， 此时失效缓存的时候出错，缓存内数据仍是旧版本；

### 缓存更新的设计模式有四种： ###

Cache aside：**查询**：先查缓存，缓存没有就查数据库，然后加载至缓存内；**更新**：先更新数据库，然后让缓存失效；或者先失效缓存然后更新数据库；

Read through：**在查询操作中更新缓存**，即当缓存失效时，Cache Aside 模式是由调用方负责把数据加载入缓存，而 Read Through 则用缓存服务自己来加载；

Write through：**在更新数据时发生**。当有数据更新的时候，如果没有命中缓存，直接更新数据库，然后返回。如果命中了缓存，则更新缓存，然后由缓存自己更新数据库；

Write behind caching：俗称write back，**在更新数据的时候，只更新缓存，不更新数据库，缓存会异步地定时批量更新数据库**；

Cache aside：  
为了避免在并发场景下，多个请求同时更新同一个缓存导致脏数据，因此不能直接更新缓存而是另缓存失效。

先更新数据库后失效缓存：并发场景下，推荐使用延迟失效（写请求完成后给缓存设置1s过期时间），在读请求缓存数据时若redis内已有该数据（其他写请求还未结束）则不更新。当redis内没有该数据的时候（其他写请求已另该缓存失效），读请求才会更新redis内的数据。这里的读请求缓存数据可以加上失效时间，以防第二步操作异常导致的不一致情况。

先失效缓存后更新数据库：并发场景下，推荐使用延迟失效（写请求开始前给缓存设置1s过期时间），在写请求失效缓存时设置一个1s延迟时间，然后再去更新数据库的数据，此时其他读请求仍然可以读到缓存内的数据，当数据库端更新完成后，缓存内的数据已失效，之后的读请求会将数据库端最新的数据加载至缓存内保证缓存和数据库端数据一致性；在这种方案下，第二步操作异常不会引起数据不一致，例如设置了缓存1s后失效，然后在更新数据库时报错，即使缓存失效，之后的读请求仍然会把更新前的数据重新加载到缓存内。

**推荐使用先失效缓存，后更新数据库，配合延迟失效来更新缓存的模式；**

### 四种缓存更新模式的优缺点： ###

Cache Aside：**实现起来较简单，但需要维护两个数据存储**，一个是**缓存**（Cache），一个是**数据库**（Repository）；  
Read/Write Through：只需要**维护一个数据存储（缓存）**，但是实现起来要复杂一些；  
Write Behind Caching：与Read/Write Through 类似，区别是Write Behind Caching的**数据持久化操作是异步**的，但是Read/Write Through 更新模式的**数据持久化操作是同步的**。优点是直接操作**内存速度快，多次操作可以合并持久化到数据库**。缺点是数据可能会丢失，例如系统断电等。  
缓存本身就是通过牺牲强一致性来提高性能，因此使用缓存提升性能，就会有数据更新的延迟性。这就需要我们在评估需求和设计阶段根据实际场景去做权衡了。

## 6、缓存降级 ##

缓存降级是**指当访问量剧增、服务出现问题**（如响应时间慢或不响应）或**非核心服务影响到核心流程的性能时**，**即使是有损部分其他服务，仍然需要保证主服务可用**。可以将其他次要服务的数据进行缓存降级，从而提升主服务的稳定性。

降级的目的是**保证核心服务可用，即使是有损的**。如去年双十一的时候淘宝购物车无法修改地址只能使用默认地址，这个服务就是被降级了，这里阿里保证了订单可以正常提交和付款，但修改地址的服务可以在服务器压力降低，并发量相对减少的时候再恢复。

降级可以根据实时的监控数据进行**自动降级**也可以**配置开关人工降级**。是否需要降级，哪些服务需要降级，在什么情况下再降级，取决于大家对于系统功能的取舍。

**参考资料**  
https://blog.csdn.net/u011863024/article/details/107476187\#comments\_16836630  
https://blog.csdn.net/qq\_34337272/article/details/80012284  
https://blog.csdn.net/xlgen157387/article/details/79470556  
https://blog.csdn.net/wsdc0521/article/details/106907436  
https://www.cnblogs.com/javastack/p/12848446.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/b742e74cd3e44e1e8814863dece797eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/fe53c750572d46758cb61209d0672ead.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/9f7209dd76ce458bbd6c8a47fd3a4daa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/65b90aca32754d7eb09a5091aa745943.png