Redis典型应用
📖 本文导读 :围绕 Redis 的两大典型应用场景展开------缓存 与分布式锁,从概念、策略到高频面试考点逐层深入。
目录
- [1. 缓存(cache)](#1. 缓存(cache))
- [1.1 什么是缓存](#1.1 什么是缓存)
- [1.2 使用Redis作为缓存](#1.2 使用Redis作为缓存)
- [1.3 缓存的更新策略](#1.3 缓存的更新策略)
- [1.4 缓存预热、缓存穿透、缓存雪崩、缓存击穿](#1.4 缓存预热、缓存穿透、缓存雪崩、缓存击穿)
- [2. Redis典型应用 - 分布式锁](#2. Redis典型应用 - 分布式锁)
- [2.1 什么是分布式锁](#2.1 什么是分布式锁)
- [2.2 分布式锁的基础实现](#2.2 分布式锁的基础实现)
- [2.3 引入过期时间](#2.3 引入过期时间)
- [2.4 引入校验id](#2.4 引入校验id)
- [2.5 引入lua](#2.5 引入lua)
- [2.6 watch dog (看门狗)](#2.6 watch dog (看门狗))
- [2.7 Redlock 算法](#2.7 Redlock 算法)
- [3. 小结](#3. 小结)
- [4. 经典面试题](#4. 经典面试题)
✅️ 1. 缓存(cache)
1.1 什么是缓存
🖥️ 缓存时计算机中的一个经典概念,很多场景都会涉及到。其核心思路就是说就一些常用的数据放到比较容易获取的地方,方便读取。
**举例:**当我们在乘坐飞机时需要使用身份证,我们可以将身份证放到我们的背包内(空间更大),但是每次刷身份证都需要开背包,非常不方便。因此我们就可以将身份证放到衣服口袋中,衣服口袋虽然小,但是存取非常方便,这样的话我们就可以快速拿出我们的身份证,而不需要去开我们的背包。此时的"衣服口袋"就可以作为"背包"的缓存,使用缓存可以大大的提高访问效率。
🐒 其实上面说的"容易获取"是一个相对的概念。作为程序员,我们知道对于硬件的访问速度,通常来说:
CPU寄存器 > 内存 > 磁盘 > 网络。那么磁盘对于网络来说是"容易获取的",因此磁盘就可以作为网络的缓存;内存对于磁盘来说是"容易获取的",因此内存就可以作为磁盘的缓存;CPU寄存器对于内存来说是"容易获取的",因此CPU寄存器就可以作为内存的缓存。
对于计算机硬件来说, 往往访问速度越快的设备, 成本越⾼, 存储空间越⼩.
缓存是更快, 但是空间上往往是不⾜的. 因此⼤部分的时候, 缓存只放⼀些 热点数据 (访问频繁的数据),就⾮常有⽤了.
📦 关于 "⼆⼋定律"
20%的热点数据, 能够应对80%的访问场景.因此只需要把这少量的热点数据缓存起来, 就可以应对⼤多数场景, 从⽽在整体上有明显的性能提升.
1.2 使用Redis作为缓存
在⼀个⽹站中, 我们经常会使⽤关系型数据库 (⽐如 MySQL) 来存储数据.关系型数据库虽然功能强⼤, 但是有⼀个很⼤的缺陷, 就是性能不⾼. (换⽽⾔之, 进⾏⼀次查询操作消耗的系统资源较多).
✍️ 为什么说关系型数据库性能不⾼?
- 数据库把数据存储在硬盘上, 硬盘的
IO速度并不快. 尤其是随机访问.- 如果查询不能命中索引, 就需要进⾏表的遍历, 这就会⼤ 增加硬盘
IO次数.- 关系型数据库对于
SQL的执⾏会做⼀系列的解析, 校验, 优化⼯作.- 如果是⼀些复杂查询, ⽐如联合查询, 需要进⾏笛卡尔积操作, 效率更是降低很多.
- ...
因此, 如果访问数据库的并发量⽐较⾼, 对于数据库的压⼒是很⼤的, 很容易就会使数据库服务器宕机.
🧾 为什么并发量⾼了就会宕机?
服务器每次处理⼀个请求, 都是需要消耗⼀定的硬件资源的. 所谓的硬件资源包括不限于·
CPU,内存, 硬盘, ⽹络带宽...⼀个服务器的硬件资源本⾝是有限的. ⼀个请求消耗⼀份资源, 请求多了, ⾃然把资源就耗尽了. 后续的请求没有资源可⽤, ⾃然就⽆法正确处理. 更严重的还会导致服务器程序的代码出现崩溃
那么如何才能让数据库能够支撑更大的并发量?核心思路有两个:
- 开源:引入更多硬件,部署更多的数据库实例,构建数据库集群(主从复制,分库表等等)。
- 节流:引入缓存,使用缓存来存放经常需要访问的热点数据,从而降低直接访问数据库的请求数量。
实际开发中,上面的两种方式都是配合使用的!

1.3 缓存的更新策略
❓️ 那么到底哪些才算是"热点数据"呢?

通用缓存策略如下:
FIFO(First In First Out)先进先出策略:把缓存中存在时间最久的(也就是先来的数据)淘汰掉。LRU(Least Recently Used)淘汰最久未使用的:记录每一个key的最近访问时间,把最近访问时间最老的key淘汰掉。LFU(Least Frequently Used)淘汰访问次数最少的:记录每一个可以最近一段时间的访问次数,把访问次数最少的淘汰掉。Random随机淘汰: 从所有的key中抽取幸运儿被随机淘汰。
当然,上述的淘汰策略我们可以自己手动实现,对于Redis而言也提供了内置的淘汰策略,Redis内置的淘汰策略如下:
volatile-lru当内存不⾜以容纳新写⼊数据时,从设置了过期时间的key中使⽤LRU(最近最少使⽤)算法进⾏淘汰
allkeys-lru当内存不⾜以容纳新写⼊数据时,从所有key中使⽤LRU(最近最少使⽤)算法进⾏淘汰.
volatile-lfu 4.0版本新增,当内存不⾜以容纳新写⼊数据时,在过期的key中,使⽤LFU算法进⾏删除key.
allkeys-lfu 4.0版本新增,当内存不⾜以容纳新写⼊数据时,从所有key中使⽤LFU算法进⾏淘汰.
volatile-random当内存不⾜以容纳新写⼊数据时,从设置了过期时间的key中,随机淘汰数据.
allkeys-random当内存不⾜以容纳新写⼊数据时,从所有key中随机淘汰数据.
volatile-ttl在设置了过期时间的key中,根据过期时间进⾏淘汰,越早过期的优先被淘汰.(相当于FIFO, 只不过是局限于过期的key)
noeviction默认策略,当内存不⾜以容纳新写⼊数据时,新写⼊操作会报错.
整体来说 Redis 提供的策略和我们上述介绍的通⽤策略是基本⼀致的. 只不过 Redis 这⾥会针对 "过期key" 和 "全部 key" 做分别处理.
1.4 缓存预热、缓存穿透、缓存雪崩、缓存击穿
📌 本节话题是【高频面试考点】
① 缓存预热 (Cache preheating)
使⽤ Redis作为MySQL的缓存的时候, 当 Redis 刚刚启动, 或者 Redis ⼤批key 失效之后, 此时由于Redis ⾃⾝相当于是空着的, 没啥缓存数据, 那么 MySQL 就可能直接被访问到, 从⽽造成较⼤的压⼒.因此就需要提前把热点数据准备好, 直接写⼊到 Redis 中. 使Redis可以尽快为 MySQL 撑起保护伞.热点数据可以基于之前介绍的统计的⽅式⽣成即可. 这份热点数据不⼀定⾮得那么 "准确", 只要能帮助MySQL 抵挡⼤部分请求即可. 随着程序运⾏的推移, 缓存的热点数据会逐渐⾃动调整, 来更适应当前情况.
② 缓存穿透 (Cache penetration)

③ 缓存雪崩 (Cache avalanche)

④ 缓存穿透 (Cache breakdown)

✅️ 2. Redis典型应用 - 分布式锁
2.1 什么是分布式锁
对于一个分布式系统,仍然存在多个节点访问同一个公共资源的情况,此时就需要使用"锁"来做互斥控制,避免出现类似于"线程安全"的问题。但是像C++中的mutex只能在当前进程中生效,对于分布式系统中多进程多主机的场景却无能为力,此时分布式锁就登场了!
📌 分布式锁的本质就是使用一个或者一组公共的服务器,来记录加锁状态。
redis是一种典型的可以用来实现分布式锁的方案,但是不是是唯一的方案,业界可能也会采用mysql/zookeeper这样的组件来是西安分布式锁的效果。
2.2 分布式锁的基础实现
思路非常简单,本质就是通过一个键值对来标记锁的状态。
举个例⼦: 考虑买票的场景, 现在⻋站提供了若⼲个⻋次, 每个⻋次的票数都是固定的.
!在这里插入图片描述(https://i-blog.csdnimg.cn/direct/82abd67b1ecd4eb084f8bedc4a215a0c##### 2.3 引入过期时间入过期时间
当 服务器1 加锁之后, 开始处理买票的过程中, 如果 服务器1 意外宕机了, 就会导致解锁操作 (删除该key) 不能执⾏. 就可能引起其他服务器始终⽆法获取到锁的情况.为了解决这个问题, 可以在设置 key 的同时引⼊过期时间. 即这个锁最多持有多久, 就应该被释放.
💡 提示:可以使⽤
set ex nx的⽅式, 在设置锁的同时把过期时间设置进去.
📌 注意! 此处的过期时间只能使⽤⼀个命令的⽅式设置.如果分开多个操作, ⽐如
setnx之后, 再来⼀个单独的expire, 由于Redis的多个指令之间不存在关联, 并且即使使⽤了事务也不能保证这两个操作都⼀定成功, 因此就可能出现setnx成功, 但是expire失败的情况.此时仍然会出现⽆法正确释放锁的问题.
2.4 引入校验id
对于 Redis 中写⼊的加锁键值对, 其他的节点也是可以删除的.
⽐如 服务器
1写⼊⼀个"001": 1这样的键值对, 服务器2是完全可以把"001"给删除掉的.当然, 服务器
2不会进⾏这样的 "恶意删除" 操作, 不过不能保证因为⼀些bug导致 服务器2把锁误删除.
为了解决上述问题, 我们可以引⼊⼀个校验 id .
⽐如可以把设置的键值对的值, 不再是简单的设为⼀个 1, ⽽是设成服务器的编号. 形如 "001": "服务器1".
这样就可以在删除 key (解锁)的时候, 先校验当前删除key的服务器是否是当初加锁的服务器, 如果是,才能真正删除; 不是, 则不能删除.
逻辑⽤伪代码描述如下:
java
String key = [要加锁的资源 id];
String serverId = [服务器的编号];
// 加锁, 设置过期时间为 10s
redis.set(key, serverId, "NX", "EX", "10s");
// 执⾏各种业务逻辑, ⽐如修改数据库数据.
doSomeThing();
// 解锁, 删除 key. 但是删除前要检验下 serverId 是否匹配.
if (redis.get(key) == serverId) {
redis.del(key);
}
但是很明显, 解锁逻辑是两步操作 "get" 和 "del", 这样做并⾮是原⼦的.
2.5 引入lua
为了使得get操作和del,即解锁操作是原子的,可以使用Redis的Lua脚本功能。
!在这里插入图片描述(https://i-blog.csdnimg.cn/direct/e42f327e09434a258f664fc3fd40bf##### 2.6 watch dog(看门狗) (看门狗 )
引入过期时间,校验id,和lua后,依然存在一个问题。当我们设置了key过期时间之后(比如10秒),任然存在一定的可能性,当任务还没有执行完,key就先过期了,这会导致锁提前失效。
把这个过期时间设置的⾜够⻓, ⽐如
30s, 是否能解决这个问题呢? 很明显, 设置多⻓时间合适, 是⽆⽌境的. 即使设置再⻓,也不能完全保证就没有提前失效的情况.⽽且如果设置的太⻓了, 万⼀对应的服务器挂了, 此时其他服务器也不能及时的获
到锁.因此相⽐于设置⼀个固定的⻓时间, 不如动态的调整时间更合适.
所谓的看门狗(watch dog),本质就是加锁的服务器上的一个单独的线程,通过这个线程来对锁的过期时间进行"续约"操作。
📌 注意:这个线程是业务服务器上的线程,而不是Redis服务器上的线程。
具体例子:
初始情况下设置过期时间为 10s. 同时设定看⻔狗线程每隔3s检测⼀次.那么当3s时间到的时候, 看⻔狗就会判定当前任务是否完成。
- 如果任务已经完成, 则直接通过
lua脚本的⽅式, 释放锁(删除 key). - 如果任务未完成, 则把过期时间重写设置为
10s. (即 "续约")
🐻 看门狗也是一个比较广义的概念,很多场景都会涉及到这种针对过期时间的操作,很多时候都会引入"看门狗"机制。
2.7 Redlock 算法
对于真实生成环境中,Redis一般都是以集群的范式部署的(至少是主从的形式,而不是单机),那么就可能会出现如下的极端情况:
⚠️ 服务器
1向master节点进⾏加锁操作. 这个写⼊key的过程刚刚完成,master挂了;slave节点升级成了新的master节点. 但是由于刚才写⼊的这个key尚未来得及同步给slave呢, 此时就相当于 服务器1的加锁操作形同虚设了, 服务器2仍然可以进⾏加锁 (即给新的master写⼊key.因为新的master不包含刚才的key).
为了解决这个问题,Redis的作者就提出了Redlock算法。具体步示例和步骤如下:
我们引⼊⼀组Redis节点. 其中每⼀组 Redis 节点都包含⼀个主节点和若⼲从节点. 并且组和组之间存储的数据都是⼀致的, 相互之间是 "备份" 关系(⽽并⾮是数据集合的⼀部分, 这点有别于 Redis cluster).加锁的时候, 按照⼀定的顺序, 写多个master节点. 在写锁的时候需要设定操作的 "超时时间". ⽐如50ms. 即如果setnx操作超过了 50ms 还没有成功, 就视为加锁失败.

如果给某个节点加锁失败, 就⽴即再尝试下⼀个节点,当加锁成功的节点数超过总节点数的⼀半, 才视为加锁成功。
如上图, ⼀共五个节点, 三个加锁成功, 两个失败, 此时视为加锁成功.这样的话, 即使有某些节点挂了, 也不影响锁的正确性.
🎼 那么是否可能出现上述节点都同时遇到这种极端情况呢?理论上这件事是可能发⽣的, 但是概率太⼩了. ⼯程上就可以忽略不计了.
同理, 释放锁的时候, 也需要把所有节点都进⾏解锁操作. (即使是之前超时的节点, 也要尝试解锁, 尽量保证逻辑严密).
简⽽⾔之, Redlock 算法的核⼼就是, 加锁操作不能只写给⼀个 Redis 节点, ⽽要写个多个 !! 分布式系统中任何⼀个节点都是不可靠的. 最终的加锁成功结论是 "少数服从多数的"。
由于⼀个分布式系统不⾄于⼤部分节点都同时出现故障, 因此这样的可靠性要⽐单个节点来说靠谱不少。
✅️ 3. 小结
本文围绕 Redis 的两个典型应用场景------缓存 与分布式锁------做了系统梳理,核心要点可以归纳如下:
缓存部分
- 缓存的本质是把热点数据放到访问更快、但容量更小的存储介质上,用「空间换时间」,遵循二八定律:20% 的热点数据应对 80% 的访问。
- 关系型数据库性能瓶颈主要来自磁盘 IO、无索引全表扫描、SQL 解析优化开销以及复杂查询的笛卡尔积,引入 Redis 缓存可以「节流」,与「开源」(集群、分库分表)配合使用效果最佳。
- 缓存淘汰策略有 FIFO、LRU、LFU、Random 等通用思路,Redis 内置策略在此基础上按「过期 key」与「全部 key」分别处理,如
volatile-lru、allkeys-lru、volatile-lfu、allkeys-lfu、volatile-random、allkeys-random、volatile-ttl、noeviction。 - 缓存三大高频问题:缓存预热 (提前把热点数据写入 Redis)、缓存穿透 (查询不存在的数据,可加布隆过滤器或缓存空值)、缓存雪崩 (大量 key 同时失效,可加随机过期时间、多级缓存)、缓存击穿(热点 key 失效瞬间被大量请求打到数据库,可加互斥锁或逻辑过期)。
分布式锁部分
- 分布式锁的本质是用一个(或一组)公共服务器记录加锁状态,Redis 是典型实现方案之一,MySQL、Zookeeper 同样可以实现。
- 演进路线:基础键值对加锁 → 引入过期时间(
set ex nx一条命令完成)→ 引入校验 id(防止误删他人锁)→ 引入 Lua 脚本(保证 get + del 原子性)→ 引入看门狗(业务服务器线程定时续约)→ Redlock 算法(多节点加锁,超过半数成功才算加锁成功)。 - Redlock 的核心思想:加锁不能只写一个 Redis 节点,而要写多个节点,最终以「少数服从多数」判定加锁是否成功,从而规避主从切换导致锁丢失的极端情况。
✅️ 4. 经典面试题
Q1:为什么使用 Redis 作为缓存,而不是直接用 MySQL?
MySQL 数据存储在磁盘上,随机 IO 慢;查询不走索引会全表扫描;SQL 执行还要做解析、校验、优化;复杂查询涉及笛卡尔积。并发量高时数据库资源容易被耗尽甚至宕机。Redis 基于内存,读写性能高,把热点数据放在Redis中可大幅降低数据库压力。
Q2:Redis 有哪些内存淘汰策略?如何选择?
共 8 种:volatile-lru、allkeys-lru、volatile-lfu、allkeys-lfu、volatile-random、allkeys-random、volatile-ttl、noeviction。若缓存数据都有过期时间且希望保留热点,选 allkeys-lru;若部分 key 需要持久保留,选 volatile-lru;纯缓存场景一般推荐 allkeys-lru。
Q3:缓存穿透、缓存击穿、缓存雪崩有什么区别?
- 缓存穿透:查询的数据在缓存和数据库中都不存在,请求每次都打到数据库。解决方案:布隆过滤器、缓存空值。
- 缓存击穿 :某个热点
key过期瞬间,大量并发请求直接打到数据库。解决方案:互斥锁重建缓存、热点数据逻辑过期。 - 缓存雪崩 :大量
key在同一时间集中失效,或Redis宕机,导致请求全部涌向数据库。解决方案:过期时间加随机值、多级缓存、Redis高可用集群、限流降级。
Q4:如何用 Redis 实现一个分布式锁?
基本思路:用 SET key value NX EX seconds 一条命令完成加锁并设置过期时间;value 存服务器唯一标识用于校验;解锁时用 Lua 脚本保证「判断 value 是否匹配 + 删除 key」的原子性;对于执行时间不确定的任务,引入看门狗线程定时续约;对可靠性要求极高的场景使用 Redlock 算法向多个独立 Redis 节点加锁,超过半数成功才算加锁成功。
Q5:为什么解锁必须用 Lua 脚本?
解锁需要先 get 判断锁是否属于自己,再 del 删除,这是两步操作。如果不用 Lua,在get与del之间锁可能已过期并被其他服务器获取,此时del会误删别人的锁。Lua 脚本在 Redis 中单线程原子执行,可保证判断与删除不可分割。
Q6:什么是 Redlock 算法?它解决了什么问题?
Redlock 解决的是主从架构下「加锁写入 master 后 master 宕机、key 尚未同步到 slave,slave 升级为新 master 导致锁丢失」的问题。做法是部署 N 个相互独立的 Redis 节点,依次加锁并设置超时时间,当成功节点数超过 N/2 时视为加锁成功;释放锁时向所有节点发起解锁。核心思想是加锁不能只写一个节点,以多数派保证可靠性。
Q7:看门狗机制是 Redis 自带的吗?
不是。看门狗是业务服务器上的一个独立线程,定时检测任务是否完成:完成则通过Lua脚本释放锁,未完成则重置过期时间(续约)。它运行在客户端侧,而非Redis服务端。