mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-06-16 18:10:13 +08:00
483 lines
25 KiB
Markdown
483 lines
25 KiB
Markdown
---
|
||
title: Redis常见面试题总结(下)
|
||
category: 数据库
|
||
tag:
|
||
- Redis
|
||
head:
|
||
- - meta
|
||
- name: keywords
|
||
content: Redis基础,Redis常见数据结构,Redis线程模型,Redis内存管理,Redis事务,Redis性能优化
|
||
- - meta
|
||
- name: description
|
||
content: 一篇文章总结Redis常见的知识点和面试题，涵盖Redis基础、Redis常见数据结构、Redis线程模型、Redis内存管理、Redis事务、Redis性能优化等内容。
|
||
---
|
||
|
||
## Redis 事务
|
||
|
||
### 如何使用 Redis 事务？
|
||
|
||
Redis 可以通过 **`MULTI`，`EXEC`，`DISCARD` 和 `WATCH`** 等命令来实现事务(transaction)功能。
|
||
|
||
```bash
|
||
> MULTI
|
||
OK
|
||
> SET PROJECT "JavaGuide"
|
||
QUEUED
|
||
> GET PROJECT
|
||
QUEUED
|
||
> EXEC
|
||
1) OK
|
||
2) "JavaGuide"
|
||
```
|
||
|
||
[`MULTI`](https://redis.io/commands/multi) 命令后可以输入多个命令，Redis 不会立即执行这些命令，而是将它们放到队列，当调用了 [`EXEC`](https://redis.io/commands/exec) 命令后，再执行所有的命令。
|
||
|
||
这个过程是这样的：
|
||
|
||
1. 开始事务（`MULTI`）；
|
||
2. 命令入队(批量操作 Redis 的命令，先进先出（FIFO）的顺序执行)；
|
||
3. 执行事务(`EXEC`)。
|
||
|
||
你也可以通过 [`DISCARD`](https://redis.io/commands/discard) 命令取消一个事务，它会清空事务队列中保存的所有命令。
|
||
|
||
```bash
|
||
> MULTI
|
||
OK
|
||
> SET PROJECT "JavaGuide"
|
||
QUEUED
|
||
> GET PROJECT
|
||
QUEUED
|
||
> DISCARD
|
||
OK
|
||
```
|
||
|
||
你可以通过[`WATCH`](https://redis.io/commands/watch) 命令监听指定的 Key，当调用 `EXEC` 命令执行事务时，如果一个被 `WATCH` 命令监视的 Key 被 **其他客户端/Session** 修改的话，整个事务都不会被执行。
|
||
|
||
```bash
|
||
# 客户端 1
|
||
> SET PROJECT "RustGuide"
|
||
OK
|
||
> WATCH PROJECT
|
||
OK
|
||
> MULTI
|
||
OK
|
||
> SET PROJECT "JavaGuide"
|
||
QUEUED
|
||
|
||
# 客户端 2
|
||
# 在客户端 1 执行 EXEC 命令提交事务之前修改 PROJECT 的值
|
||
> SET PROJECT "GoGuide"
|
||
|
||
# 客户端 1
|
||
# 修改失败，因为 PROJECT 的值被客户端2修改了
|
||
> EXEC
|
||
(nil)
|
||
> GET PROJECT
|
||
"GoGuide"
|
||
```
|
||
|
||
不过，如果 **WATCH** 与 **事务** 在同一个 Session 里，并且被 **WATCH** 监视的 Key 被修改的操作发生在事务内部，这个事务是可以被执行成功的（相关 issue ：[WATCH 命令碰到 MULTI 命令时的不同效果](https://github.com/Snailclimb/JavaGuide/issues/1714)）。
|
||
|
||
事务内部修改 WATCH 监视的 Key：
|
||
|
||
```bash
|
||
> SET PROJECT "JavaGuide"
|
||
OK
|
||
> WATCH PROJECT
|
||
OK
|
||
> MULTI
|
||
OK
|
||
> SET PROJECT "JavaGuide1"
|
||
QUEUED
|
||
> SET PROJECT "JavaGuide2"
|
||
QUEUED
|
||
> SET PROJECT "JavaGuide3"
|
||
QUEUED
|
||
> EXEC
|
||
1) OK
|
||
2) OK
|
||
3) OK
|
||
127.0.0.1:6379> GET PROJECT
|
||
"JavaGuide3"
|
||
```
|
||
|
||
事务外部修改 WATCH 监视的 Key：
|
||
|
||
```bash
|
||
> SET PROJECT "JavaGuide"
|
||
OK
|
||
> WATCH PROJECT
|
||
OK
|
||
> SET PROJECT "JavaGuide2"
|
||
OK
|
||
> MULTI
|
||
OK
|
||
> GET USER
|
||
QUEUED
|
||
> EXEC
|
||
(nil)
|
||
```
|
||
|
||
Redis 官网相关介绍 [https://redis.io/topics/transactions](https://redis.io/topics/transactions) 如下：
|
||
|
||
|
||
|
||
### Redis 事务支持原子性吗？
|
||
|
||
Redis 的事务和我们平时理解的关系型数据库的事务不同。我们知道事务具有四大特性： **1. 原子性**，**2. 隔离性**，**3. 持久性**，**4. 一致性**。
|
||
|
||
1. **原子性（Atomicity）：** 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
|
||
2. **隔离性（Isolation）：** 并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的；
|
||
3. **持久性（Durability）：** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
|
||
4. **一致性（Consistency）：** 执行事务前后，数据保持一致，多个事务对同一个数据读取的结果是相同的；
|
||
|
||
Redis 事务在运行错误的情况下，除了执行过程中出现错误的命令外，其他命令都能正常执行。并且，Redis 事务是不支持回滚（roll back）操作的。因此，Redis 事务其实是不满足原子性的（而且不满足持久性）。
|
||
|
||
Redis 官网也解释了自己为啥不支持回滚。简单来说就是 Redis 开发者们觉得没必要支持回滚，这样更简单便捷并且性能更好。Redis 开发者觉得即使命令执行错误也应该在开发过程中就被发现而不是生产过程中。
|
||
|
||
|
||
|
||
你可以将 Redis 中的事务就理解为 ：**Redis 事务提供了一种将多个命令请求打包的功能。然后，再按顺序执行打包的所有命令，并且不会被中途打断。**
|
||
|
||
除了不满足原子性之外，事务中的每条命令都会与 Redis 服务器进行网络交互，这是比较浪费资源的行为。明明一次批量执行多个命令就可以了，这种操作实在是看不懂。
|
||
|
||
因此，Redis 事务是不建议在日常开发中使用的。
|
||
|
||
**相关 issue** :
|
||
|
||
- [issue452: 关于 Redis 事务不满足原子性的问题](https://github.com/Snailclimb/JavaGuide/issues/452) 。
|
||
- [Issue491:关于 redis 没有事务回滚？](https://github.com/Snailclimb/JavaGuide/issues/491)
|
||
|
||
### 如何解决 Redis 事务的缺陷？
|
||
|
||
Redis 从 2.6 版本开始支持执行 Lua 脚本，它的功能和事务非常类似。我们可以利用 Lua 脚本来批量执行多条 Redis 命令，这些 Redis 命令会被提交到 Redis 服务器一次性执行完成，大幅减小了网络开销。
|
||
|
||
一段 Lua 脚本可以视作一条命令执行，一段 Lua 脚本执行过程中不会有其他脚本或 Redis 命令同时执行，保证了操作不会被其他指令插入或打扰。
|
||
|
||
不过，如果 Lua 脚本运行时出错并中途结束，出错之后的命令是不会被执行的。并且，出错之前执行的命令是无法被撤销的，无法实现类似关系型数据库执行失败可以回滚的那种原子性效果。因此， **严格来说的话，通过 Lua 脚本来批量执行 Redis 命令实际也是不完全满足原子性的。**
|
||
|
||
如果想要让 Lua 脚本中的命令全部执行，必须保证语句语法和命令都是对的。
|
||
|
||
另外，Redis 7.0 新增了 [Redis functions](https://redis.io/docs/manual/programmability/functions-intro/) 特性，你可以将 Redis functions 看作是比 Lua 更强大的脚本。
|
||
|
||
## Redis 性能优化
|
||
|
||
### 使用批量操作减少网络传输
|
||
|
||
一个 Redis 命令的执行可以简化为以下 4 步：
|
||
|
||
1. 发送命令
|
||
2. 命令排队
|
||
3. 命令执行
|
||
4. 返回结果
|
||
|
||
其中，第 1 步和第 4 步耗费时间之和称为 **Round Trip Time (RTT,往返时间)** ，也就是数据在网络上传输的时间。
|
||
|
||
**使用批量操作可以减少网络传输次数，进而有效减小网络开销，大幅减少 RTT。**
|
||
|
||
#### 原生批量操作命令
|
||
|
||
Redis 中有一些原生支持批量操作的命令，比如：
|
||
|
||
- `mget`(获取一个或多个指定 key 的值)、`mset`(设置一个或多个指定 key 的值)、
|
||
- `hmget`(获取指定哈希表中一个或者多个指定字段的值)、`hmset`(同时将一个或多个 field-value 对设置到指定哈希表中)、
|
||
- `sadd`（向指定集合添加一个或多个元素）
|
||
- ......
|
||
|
||
不过，在 Redis 官方提供的分片集群解决方案 Redis Cluster 下，使用这些原生批量操作命令可能会存在一些小问题需要解决。就比如说 `mget` 无法保证所有的 key 都在同一个 **hash slot**（哈希槽）上，`mget`可能还是需要多次网络传输，原子操作也无法保证了。不过，相较于非批量操作，还是可以节省不少网络传输次数。
|
||
|
||
整个步骤的简化版如下（通常由 Redis 客户端实现，无需我们自己再手动实现）：
|
||
|
||
1. 找到 key 对应的所有 hash slot；
|
||
2. 分别向对应的 Redis 节点发起 `mget` 请求获取数据；
|
||
3. 等待所有请求执行结束，重新组装结果数据，保持跟入参 key 的顺序一致，然后返回结果。
|
||
|
||
如果想要解决这个多次网络传输的问题，比较常用的办法是自己维护 key 与 slot 的关系。不过这样不太灵活，虽然带来了性能提升，但同样让系统复杂性提升。
|
||
|
||
> Redis Cluster 并没有使用一致性哈希，采用的是 **哈希槽分区** ，每一个键值对都属于一个 **hash slot**（哈希槽） 。当客户端发送命令请求的时候，需要先根据 key 通过上面的计算公示找到的对应的哈希槽，然后再查询哈希槽和节点的映射关系，即可找到目标 Redis 节点。
|
||
>
|
||
> 我在 [Redis 集群详解（付费）](https://javaguide.cn/database/redis/redis-cluster.html) 这篇文章中详细介绍了 Redis Cluster 这部分的内容，感兴趣地可以看看。
|
||
|
||
#### pipeline
|
||
|
||
对于不支持批量操作的命令，我们可以利用 **pipeline（流水线)** 将一批 Redis 命令封装成一组，这些 Redis 命令会被一次性提交到 Redis 服务器，只需要一次网络传输。不过，需要注意控制一次批量操作的 **元素个数**(例如 500 以内，实际也和元素字节数有关)，避免网络传输的数据量过大。
|
||
|
||
与`mget`、`mset`等原生批量操作命令一样，pipeline 同样在 Redis Cluster 上使用会存在一些小问题。原因类似，无法保证所有的 key 都在同一个 **hash slot**（哈希槽）上。如果想要使用的话，客户端需要自己维护 key 与 slot 的关系。
|
||
|
||
原生批量操作命令和 pipeline 的是有区别的，使用的时候需要注意：
|
||
|
||
- 原生批量操作命令是原子操作，pipeline 是非原子操作；
|
||
- pipeline 可以打包不同的命令，原生批量操作命令不可以；
|
||
- 原生批量操作命令是 Redis 服务端支持实现的，而 pipeline 需要服务端和客户端的共同实现。
|
||
|
||
另外，pipeline 不适用于执行顺序有依赖关系的一批命令。就比如说，你需要将前一个命令的结果给后续的命令使用，pipeline 就没办法满足你的需求了。对于这种需求，我们可以使用 **Lua 脚本** 。
|
||
|
||
#### Lua 脚本
|
||
|
||
Lua 脚本同样支持批量操作多条命令。一段 Lua 脚本可以视作一条命令执行，可以看作是原子操作。一段 Lua 脚本执行过程中不会有其他脚本或 Redis 命令同时执行，保证了操作不会被其他指令插入或打扰，这是 pipeline 所不具备的。
|
||
|
||
并且，Lua 脚本中支持一些简单的逻辑处理比如使用命令读取值并在 Lua 脚本中进行处理，这同样是 pipeline 所不具备的。
|
||
|
||
不过， Redis Cluster 下 Lua 脚本的原子操作也无法保证了，原因同样是无法保证所有的 key 都在同一个 **hash slot**（哈希槽）上。
|
||
|
||
### 大量 key 集中过期问题
|
||
|
||
我在前面提到过：对于过期 key，Redis 采用的是 **定期删除+惰性/懒汉式删除** 策略。
|
||
|
||
定期删除执行过程中，如果突然遇到大量过期 key 的话，客户端请求必须等待定期清理过期 key 任务线程执行完成，因为这个这个定期任务线程是在 Redis 主线程中执行的。这就导致客户端请求没办法被及时处理，响应速度会比较慢。
|
||
|
||
如何解决呢？下面是两种常见的方法：
|
||
|
||
1. 给 key 设置随机过期时间。
|
||
2. 开启 lazy-free（惰性删除/延迟释放） 。lazy-free 特性是 Redis 4.0 开始引入的，指的是让 Redis 采用异步方式延迟释放 key 使用的内存，将该操作交给单独的子线程处理，避免阻塞主线程。
|
||
|
||
个人建议不管是否开启 lazy-free，我们都尽量给 key 设置随机过期时间。
|
||
|
||
### Redis bigkey
|
||
|
||
#### 什么是 bigkey？
|
||
|
||
简单来说，如果一个 key 对应的 value 所占用的内存比较大，那这个 key 就可以看作是 bigkey。具体多大才算大呢？有一个不是特别精确的参考标准：string 类型的 value 超过 10 kb，复合类型的 value 包含的元素超过 5000 个（对于复合类型的 value 来说，不一定包含的元素越多，占用的内存就越多）。
|
||
|
||
#### bigkey 有什么危害？
|
||
|
||
除了会消耗更多的内存空间，bigkey 对性能也会有比较大的影响。因此，我们应该尽量避免写入 bigkey！
|
||
|
||
#### 如何发现 bigkey？
|
||
|
||
**1、使用 Redis 自带的 `--bigkeys` 参数来查找。**
|
||
|
||
```bash
|
||
# redis-cli -p 6379 --bigkeys
|
||
|
||
# Scanning the entire keyspace to find biggest keys as well as
|
||
# average sizes per key type. You can use -i 0.1 to sleep 0.1 sec
|
||
# per 100 SCAN commands (not usually needed).
|
||
|
||
[00.00%] Biggest string found so far '"ballcat:oauth:refresh_auth:f6cdb384-9a9d-4f2f-af01-dc3f28057c20"' with 4437 bytes
|
||
[00.00%] Biggest list found so far '"my-list"' with 17 items
|
||
|
||
-------- summary -------
|
||
|
||
Sampled 5 keys in the keyspace!
|
||
Total key length in bytes is 264 (avg len 52.80)
|
||
|
||
Biggest list found '"my-list"' has 17 items
|
||
Biggest string found '"ballcat:oauth:refresh_auth:f6cdb384-9a9d-4f2f-af01-dc3f28057c20"' has 4437 bytes
|
||
|
||
1 lists with 17 items (20.00% of keys, avg size 17.00)
|
||
0 hashs with 0 fields (00.00% of keys, avg size 0.00)
|
||
4 strings with 4831 bytes (80.00% of keys, avg size 1207.75)
|
||
0 streams with 0 entries (00.00% of keys, avg size 0.00)
|
||
0 sets with 0 members (00.00% of keys, avg size 0.00)
|
||
0 zsets with 0 members (00.00% of keys, avg size 0.00
|
||
```
|
||
|
||
从这个命令的运行结果，我们可以看出：这个命令会扫描(Scan) Redis 中的所有 key ，会对 Redis 的性能有一点影响。并且，这种方式只能找出每种数据结构 top 1 bigkey（占用内存最大的 string 数据类型，包含元素最多的复合数据类型）。
|
||
|
||
**2、分析 RDB 文件**
|
||
|
||
通过分析 RDB 文件来找出 big key。这种方案的前提是你的 Redis 采用的是 RDB 持久化。
|
||
|
||
网上有现成的代码/工具可以直接拿来使用：
|
||
|
||
- [redis-rdb-tools](https://github.com/sripathikrishnan/redis-rdb-tools) ：Python 语言写的用来分析 Redis 的 RDB 快照文件用的工具
|
||
- [rdb_bigkeys](https://github.com/weiyanwei412/rdb_bigkeys) : Go 语言写的用来分析 Redis 的 RDB 快照文件用的工具，性能更好。
|
||
|
||
### Redis 内存碎片
|
||
|
||
**相关问题** ：
|
||
|
||
1. 什么是内存碎片?为什么会有 Redis 内存碎片?
|
||
2. 如何清理 Redis 内存碎片？
|
||
|
||
**参考答案** ：[Redis 内存碎片详解](https://javaguide.cn/database/redis/redis-memory-fragmentation.html)。
|
||
|
||
## Redis 生产问题
|
||
|
||
### 缓存穿透
|
||
|
||
#### 什么是缓存穿透？
|
||
|
||
缓存穿透说简单点就是大量请求的 key 是不合理的，**根本不存在于缓存中，也不存在于数据库中** 。这就导致这些请求直接到了数据库上，根本没有经过缓存这一层，对数据库造成了巨大的压力，可能直接就被这么多请求弄宕机了。
|
||
|
||
|
||
|
||
举个例子：某个黑客故意制造一些非法的 key 发起大量请求，导致大量请求落到数据库，结果数据库上也没有查到对应的数据。也就是说这些请求最终都落到了数据库上，对数据库造成了巨大的压力。
|
||
|
||
#### 有哪些解决办法？
|
||
|
||
最基本的就是首先做好参数校验，一些不合法的参数请求直接抛出异常信息返回给客户端。比如查询的数据库 id 不能小于 0、传入的邮箱格式不对的时候直接返回错误消息给客户端等等。
|
||
|
||
**1）缓存无效 key**
|
||
|
||
如果缓存和数据库都查不到某个 key 的数据就写一个到 Redis 中去并设置过期时间，具体命令如下： `SET key value EX 10086` 。这种方式可以解决请求的 key 变化不频繁的情况，如果黑客恶意攻击，每次构建不同的请求 key，会导致 Redis 中缓存大量无效的 key 。很明显，这种方案并不能从根本上解决此问题。如果非要用这种方式来解决穿透问题的话，尽量将无效的 key 的过期时间设置短一点比如 1 分钟。
|
||
|
||
另外，这里多说一嘴，一般情况下我们是这样设计 key 的： `表名:列名:主键名:主键值` 。
|
||
|
||
如果用 Java 代码展示的话，差不多是下面这样的：
|
||
|
||
```java
|
||
public Object getObjectInclNullById(Integer id) {
|
||
// 从缓存中获取数据
|
||
Object cacheValue = cache.get(id);
|
||
// 缓存为空
|
||
if (cacheValue == null) {
|
||
// 从数据库中获取
|
||
Object storageValue = storage.get(key);
|
||
// 缓存空对象
|
||
cache.set(key, storageValue);
|
||
// 如果存储数据为空，需要设置一个过期时间(300秒)
|
||
if (storageValue == null) {
|
||
// 必须设置过期时间，否则有被攻击的风险
|
||
cache.expire(key, 60 * 5);
|
||
}
|
||
return storageValue;
|
||
}
|
||
return cacheValue;
|
||
}
|
||
```
|
||
|
||
**2）布隆过滤器**
|
||
|
||
布隆过滤器是一个非常神奇的数据结构，通过它我们可以非常方便地判断一个给定数据是否存在于海量数据中。我们需要的就是判断 key 是否合法，有没有感觉布隆过滤器就是我们想要找的那个“人”。
|
||
|
||
具体是这样做的：把所有可能存在的请求的值都存放在布隆过滤器中，当用户请求过来，先判断用户发来的请求的值是否存在于布隆过滤器中。不存在的话，直接返回请求参数错误信息给客户端，存在的话才会走下面的流程。
|
||
|
||
加入布隆过滤器之后的缓存处理流程图如下。
|
||
|
||
|
||
|
||
但是，需要注意的是布隆过滤器可能会存在误判的情况。总结来说就是： **布隆过滤器说某个元素存在，小概率会误判。布隆过滤器说某个元素不在，那么这个元素一定不在。**
|
||
|
||
_为什么会出现误判的情况呢? 我们还要从布隆过滤器的原理来说！_
|
||
|
||
我们先来看一下，**当一个元素加入布隆过滤器中的时候，会进行哪些操作：**
|
||
|
||
1. 使用布隆过滤器中的哈希函数对元素值进行计算，得到哈希值（有几个哈希函数得到几个哈希值）。
|
||
2. 根据得到的哈希值，在位数组中把对应下标的值置为 1。
|
||
|
||
我们再来看一下，**当我们需要判断一个元素是否存在于布隆过滤器的时候，会进行哪些操作：**
|
||
|
||
1. 对给定元素再次进行相同的哈希计算；
|
||
2. 得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
|
||
|
||
然后，一定会出现这样一种情况：**不同的字符串可能哈希出来的位置相同。** （可以适当增加位数组大小或者调整我们的哈希函数来降低概率）
|
||
|
||
更多关于布隆过滤器的内容可以看我的这篇原创：[《不了解布隆过滤器？一文给你整的明明白白！》](https://javaguide.cn/cs-basics/data-structure/bloom-filter/) ，强烈推荐，个人感觉网上应该找不到总结的这么明明白白的文章了。
|
||
|
||
### 缓存击穿
|
||
|
||
#### 什么是缓存击穿？
|
||
|
||
缓存击穿中，请求的 key 对应的是 **热点数据** ，该数据 **存在于数据库中，但不存在于缓存中（通常是因为缓存中的那份数据已经过期）** 。这就可能会导致瞬时大量的请求直接打到了数据库上，对数据库造成了巨大的压力，可能直接就被这么多请求弄宕机了。
|
||
|
||
|
||
|
||
举个例子 ：秒杀进行过程中，缓存中的某个秒杀商品的数据突然过期，这就导致瞬时大量对该商品的请求直接落到数据库上，对数据库造成了巨大的压力。
|
||
|
||
#### 有哪些解决办法？
|
||
|
||
- 设置热点数据永不过期或者过期时间比较长。
|
||
- 针对热点数据提前预热，将其存入缓存中并设置合理的过期时间比如秒杀场景下的数据在秒杀结束之前不过期。
|
||
- 请求数据库写数据到缓存之前，先获取互斥锁，保证只有一个请求会落到数据库上，减少数据库的压力。
|
||
|
||
#### 缓存穿透和缓存击穿有什么区别？
|
||
|
||
缓存穿透中，请求的 key 既不存在于缓存中，也不存在于数据库中。
|
||
|
||
缓存击穿中，请求的 key 对应的是 **热点数据** ，该数据 **存在于数据库中，但不存在于缓存中（通常是因为缓存中的那份数据已经过期）** 。
|
||
|
||
### 缓存雪崩
|
||
|
||
#### 什么是缓存雪崩？
|
||
|
||
我发现缓存雪崩这名字起的有点意思，哈哈。
|
||
|
||
实际上，缓存雪崩描述的就是这样一个简单的场景：**缓存在同一时间大面积的失效，导致大量的请求都直接落到了数据库上，对数据库造成了巨大的压力。** 这就好比雪崩一样，摧枯拉朽之势，数据库的压力可想而知，可能直接就被这么多请求弄宕机了。
|
||
|
||
另外，缓存服务宕机也会导致缓存雪崩现象，导致所有的请求都落到了数据库上。
|
||
|
||
|
||
|
||
举个例子 ：数据库中的大量数据在同一时间过期，这个时候突然有大量的请求需要访问这些过期的数据。这就导致大量的请求直接落到数据库上，对数据库造成了巨大的压力。
|
||
|
||
#### 有哪些解决办法？
|
||
|
||
**针对 Redis 服务不可用的情况：**
|
||
|
||
1. 采用 Redis 集群，避免单机出现问题整个缓存服务都没办法使用。
|
||
2. 限流，避免同时处理大量的请求。
|
||
|
||
**针对热点缓存失效的情况：**
|
||
|
||
1. 设置不同的失效时间比如随机设置缓存的失效时间。
|
||
2. 缓存永不失效（不太推荐，实用性太差）。
|
||
3. 设置二级缓存。
|
||
|
||
#### 缓存雪崩和缓存击穿有什么区别？
|
||
|
||
缓存雪崩和缓存击穿比较像，但缓存雪崩导致的原因是缓存中的大量或者所有数据失效，缓存击穿导致的原因主要是某个热点数据不存在与缓存中（通常是因为缓存中的那份数据已经过期）。
|
||
|
||
### 如何保证缓存和数据库数据的一致性？
|
||
|
||
细说的话可以扯很多，但是我觉得其实没太大必要（小声 BB：很多解决方案我也没太弄明白）。我个人觉得引入缓存之后，如果为了短时间的不一致性问题，选择让系统设计变得更加复杂的话，完全没必要。
|
||
|
||
下面单独对 **Cache Aside Pattern（旁路缓存模式）** 来聊聊。
|
||
|
||
Cache Aside Pattern 中遇到写请求是这样的：更新 DB，然后直接删除 cache 。
|
||
|
||
如果更新数据库成功，而删除缓存这一步失败的情况的话，简单说两个解决方案：
|
||
|
||
1. **缓存失效时间变短（不推荐，治标不治本）** ：我们让缓存数据的过期时间变短，这样的话缓存就会从数据库中加载数据。另外，这种解决办法对于先操作缓存后操作数据库的场景不适用。
|
||
2. **增加 cache 更新重试机制（常用）**： 如果 cache 服务当前不可用导致缓存删除失败的话，我们就隔一段时间进行重试，重试次数可以自己定。如果多次重试还是失败的话，我们可以把当前更新失败的 key 存入队列中，等缓存服务可用之后，再将缓存中对应的 key 删除即可。
|
||
|
||
相关文章推荐：[缓存和数据库一致性问题，看这篇就够了 - 水滴与银弹](https://mp.weixin.qq.com/s?__biz=MzIyOTYxNDI5OA==&mid=2247487312&idx=1&sn=fa19566f5729d6598155b5c676eee62d&chksm=e8beb8e5dfc931f3e35655da9da0b61c79f2843101c130cf38996446975014f958a6481aacf1&scene=178&cur_album_id=1699766580538032128#rd)。
|
||
|
||
### 哪些情况可能会导致 Redis 阻塞？
|
||
|
||
单独抽了一篇文章来总结可能会导致 Redis 阻塞的情况：[Redis 常见阻塞原因总结](./redis-memory-fragmentation.md)。
|
||
|
||
## Redis 集群
|
||
|
||
**Redis Sentinel** ：
|
||
|
||
1. 什么是 Sentinel？ 有什么用？
|
||
2. Sentinel 如何检测节点是否下线？主观下线与客观下线的区别?
|
||
3. Sentinel 是如何实现故障转移的？
|
||
4. 为什么建议部署多个 sentinel 节点（哨兵集群）？
|
||
5. Sentinel 如何选择出新的 master（选举机制）?
|
||
6. 如何从 Sentinel 集群中选择出 Leader ？
|
||
7. Sentinel 可以防止脑裂吗？
|
||
|
||
**Redis Cluster** ：
|
||
|
||
1. 为什么需要 Redis Cluster？解决了什么问题？有什么优势？
|
||
2. Redis Cluster 是如何分片的？
|
||
3. 为什么 Redis Cluster 的哈希槽是 16384 个?
|
||
4. 如何确定给定 key 的应该分布到哪个哈希槽中？
|
||
5. Redis Cluster 支持重新分配哈希槽吗？
|
||
6. Redis Cluster 扩容缩容期间可以提供服务吗？
|
||
7. Redis Cluster 中的节点是怎么进行通信的？
|
||
|
||
**参考答案** ：[Redis 集群详解（付费）](https://javaguide.cn/database/redis/redis-cluster.html)。
|
||
|
||
## Redis 使用规范
|
||
|
||
实际使用 Redis 的过程中，我们尽量要准守一些常见的规范，比如：
|
||
|
||
1. 使用连接池：避免频繁创建关闭客户端连接。
|
||
2. 尽量不使用 O(n)指令，使用 O(N)命令时要关注 N 的数量 ：例如 `hgetall`、`lrange`、`smembers`、`zrange`、`sinter` 、`sunion` 命令并非不能使用，但是需要明确 N 的值。有遍历的需求可以使用 `hscan`、`sscan`、`zscan` 代替。
|
||
3. 使用批量操作减少网络传输 ：原生批量操作命令（比如 `mget`、`mset`等等）、pipeline、Lua 脚本。
|
||
4. 尽量不适用 Redis 事务：Redis 事务实现的功能比较鸡肋，可以使用 Lua 脚本代替。
|
||
5. 禁止长时间开启 monitor：对性能影响比较大。
|
||
6. 控制 key 的生命周期：避免 Redis 中存放了太多不经常被访问的数据。
|
||
7. ......
|
||
|
||
相关文章推荐 ：[阿里云 Redis 开发规范](https://developer.aliyun.com/article/531067) 。
|
||
|
||
## 参考
|
||
|
||
- 《Redis 开发与运维》
|
||
- 《Redis 设计与实现》
|
||
- Redis Transactions : https://redis.io/docs/manual/transactions/ 。 |