Redis 缓存穿透、缓存击穿与缓存雪崩详解：标题、办理方案与最佳实践

目次

弁言
1. 缓存穿透
1.1 什么是缓存穿透？
示例：
1.2 缓存穿透的缘故因由
1.3 缓存穿透的办理方案
1.3.1 缓存空对象
1.3.2 布隆过滤器（Bloom Filter）
1.3.3 参数校验
2. 缓存击穿
2.1 什么是缓存击穿？
示例：
2.2 缓存击穿的缘故因由
2.3 缓存击穿的办理方案
2.3.1 互斥锁（Mutex Lock）
2.3.2 永不逾期 + 配景更新
2.3.3 缓存预热
3. 缓存雪崩
3.1 什么是缓存雪崩？
示例：
3.2 缓存雪崩的缘故因由
3.3 缓存雪崩的办理方案
3.3.1 设置随机逾期时间
3.3.2 多级缓存
3.3.3 限流与降级
4. 缓存穿透、缓存击穿与缓存雪崩的区别
5. 最佳实践
6. 总结

---

弁言

在使用 Redis 作为缓存体系时，缓存穿透、缓存击穿和缓存雪崩是三个常见的标题。它们不光会影响体系的性能，还可能导致数据库压力过大以致体系瓦解。本文将深入探究这三种标题的界说、缘故因由、办理方案以及最佳实践，并通过 Java 代码示例 帮助读者全面明白并有用应对这些标题。

---

1. 缓存穿透

1.1 什么是缓存穿透？

缓存穿透是指查询一个 不存在的数据，导致哀求直接穿透缓存层，直接访问数据库。由于数据库中也不存在该数据，因此每次哀求都会绕过缓存，直接访问数据库，从而导致数据库压力过大。
示例：

• 用户哀求一个不存在的商品 ID，缓存中没有该数据，哀求直接打到数据库。
  
• 恶意攻击者故意哀求大量不存在的数据，导致数据库压力激增。
  

1.2 缓存穿透的缘故因由

• 恶意攻击：攻击者故意哀求大量不存在的数据。
  
• 业务逻辑标题：业务代码未对哀求参数举行校验，导致非法哀求直接访问数据库。
  

1.3 缓存穿透的办理方案

1.3.1 缓存空对象

当查询数据库发现数据不存在时，将空效果（如 null）缓存到 Redis 中，并设置一个较短的逾期时间。如许，后续雷同的哀求可以直接从缓存中获取空效果，制止直接访问数据库。

1. import redis.clients.jedis.Jedis;
3. public class CachePenetration {
4.     private Jedis redis;
5.     private Database db;
7.     public CachePenetration(Jedis redis, Database db) {
8.         this.redis = redis;
9.         this.db = db;
10.     }
12.     public String getData(String key) {
13.         // 从缓存中获取数据
14.         String data = redis.get(key);
15.         if (data != null) {
16.             return "NULL".equals(data) ? null : data; // 返回空结果
17.         }
18.         // 从数据库中查询数据
19.         data = db.query(key);
20.         if (data == null) {
21.             redis.setex(key, 300, "NULL"); // 缓存空对象，过期时间 300 秒
22.             return null;
23.         }
24.         redis.setex(key, 3600, data); // 缓存真实数据，过期时间 1 小时
25.         return data;
26.     }
27. }

复制代码

1.3.2 布隆过滤器（Bloom Filter）

布隆过滤器是一种概率型数据布局，用于快速判定一个元素是否存在于聚会合。它可以有用过滤掉不存在的数据哀求，制止缓存穿透。

• 优点：内存占用少，查询服从高。
  
• 缺点：存在肯定的误判率（False Positive），但可以通过调解参数低沉误判率。
  

1. import com.google.common.hash.BloomFilter;
2. import com.google.common.hash.Funnels;
3. import redis.clients.jedis.Jedis;
5. public class CachePenetration {
6.     private Jedis redis;
7.     private Database db;
8.     private BloomFilter<String> bloomFilter;
10.     public CachePenetration(Jedis redis, Database db) {
11.         this.redis = redis;
12.         this.db = db;
13.         this.bloomFilter = BloomFilter.create(Funnels.stringFunnel(), 1000000, 0.001);
14.     }
16.     public String getData(String key) {
17.         // 使用布隆过滤器判断 key 是否存在
18.         if (!bloomFilter.mightContain(key)) {
19.             return null; // 如果 key 不在布隆过滤器中，直接返回
20.         }
21.         // 从缓存中获取数据
22.         String data = redis.get(key);
23.         if (data != null) {
24.             return data;
25.         }
26.         // 从数据库中查询数据
27.         data = db.query(key);
28.         if (data == null) {
29.             redis.setex(key, 300, "NULL"); // 缓存空对象
30.             return null;
31.         }
32.         redis.setex(key, 3600, data); // 缓存真实数据
33.         return data;
34.     }
35. }

复制代码

1.3.3 参数校验

在业务逻辑中对哀求参数举行校验，过滤掉非法哀求。比方，查抄商品 ID 是否为正整数，大概是否符合某种格式。

1. public class CachePenetration {
2.     private Jedis redis;
3.     private Database db;
5.     public CachePenetration(Jedis redis, Database db) {
6.         this.redis = redis;
7.         this.db = db;
8.     }
10.     private boolean validateKey(String key) {
11.         try {
12.             int id = Integer.parseInt(key);
13.             return id > 0; // 检查 key 是否为正整数
14.         } catch (NumberFormatException e) {
15.             return false;
16.         }
17.     }
19.     public String getData(String key) {
20.         if (!validateKey(key)) {
21.             return null; // 非法请求直接返回
22.         }
23.         // 其他逻辑...
24.         return null;
25.     }
26. }

复制代码

---

2. 缓存击穿

2.1 什么是缓存击穿？

缓存击穿是指 某个热门数据在缓存中逾期，同时有大量并发哀求访问该数据，导致所有哀求直接访问数据库，从而导致数据库压力激增。
示例：

• 某个热门商品的缓存逾期，同时有大量用户哀求该商品，导致数据库压力激增。
  

2.2 缓存击穿的缘故因由

• 热门数据逾期：某个热门数据的缓存逾期。
  
• 高并发哀求：大量并发哀求同时访问该热门数据。
  

2.3 缓存击穿的办理方案

2.3.1 互斥锁（Mutex Lock）

在缓存失效时，使用互斥锁确保只有一个线程去加载数据，其他线程等待加载完成后再从缓存中获取数据。

1. import redis.clients.jedis.Jedis;
2. import java.util.concurrent.locks.Lock;
3. import java.util.concurrent.locks.ReentrantLock;
5. public class CacheBreakdown {
6.     private Jedis redis;
7.     private Database db;
8.     private Lock lock = new ReentrantLock();
10.     public CacheBreakdown(Jedis redis, Database db) {
11.         this.redis = redis;
12.         this.db = db;
13.     }
15.     public String getData(String key) {
16.         // 从缓存中获取数据
17.         String data = redis.get(key);
18.         if (data != null) {
19.             return data;
20.         }
21.         // 尝试获取锁
22.         if (lock.tryLock()) {
23.             try {
24.                 // 从数据库中查询数据
25.                 data = db.query(key);
26.                 if (data != null) {
27.                     redis.setex(key, 3600, data); // 更新缓存
28.                 }
29.             } finally {
30.                 lock.unlock(); // 释放锁
31.             }
32.             return data;
33.         } else {
34.             try {
35.                 Thread.sleep(100); // 等待其他线程加载数据
36.             } catch (InterruptedException e) {
37.                 Thread.currentThread().interrupt();
38.             }
39.             return getData(key); // 重试
40.         }
41.     }
42. }

复制代码

2.3.2 永不逾期 + 配景更新

对于热门数据，可以设置缓存永不逾期，并通事配景使命定期更新缓存。

1. import redis.clients.jedis.Jedis;
2. import java.util.concurrent.Executors;
3. import java.util.concurrent.ScheduledExecutorService;
4. import java.util.concurrent.TimeUnit;
6. public class CacheBreakdown {
7.     private Jedis redis;
8.     private Database db;
10.     public CacheBreakdown(Jedis redis, Database db) {
11.         this.redis = redis;
12.         this.db = db;
13.         // 启动后台任务定期更新缓存
14.         ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
15.         scheduler.scheduleAtFixedRate(this::updateCache, 0, 1, TimeUnit.HOURS);
16.     }
18.     public String getData(String key) {
19.         // 从缓存中获取数据
20.         String data = redis.get(key);
21.         if (data != null) {
22.             return data;
23.         }
24.         // 从数据库中查询数据
25.         data = db.query(key);
26.         if (data != null) {
27.             redis.set(key, data); // 缓存永不过期
28.         }
29.         return data;
30.     }
32.     private void updateCache() {
33.         String hotData = db.queryHotData();
34.         redis.set("hot_data", hotData); // 更新缓存
35.     }
36. }

复制代码

2.3.3 缓存预热

在体系启动或低峰期，提前加载热门数据到缓存中，制止缓存击穿。

1. import redis.clients.jedis.Jedis;
3. public class CacheBreakdown {
4.     private Jedis redis;
5.     private Database db;
7.     public CacheBreakdown(Jedis redis, Database db) {
8.         this.redis = redis;
9.         this.db = db;
10.         preheatCache();
11.     }
13.     private void preheatCache() {
14.         String hotData = db.queryHotData();
15.         redis.set("hot_data", hotData); // 缓存预热
16.     }
17. }

复制代码

---

3. 缓存雪崩

3.1 什么是缓存雪崩？

缓存雪崩是指 大量缓存数据在同一时间失效，导致大量哀求直接访问数据库，从而导致数据库压力激增以致瓦解。
示例：

• 缓存中的数据设置了雷同的逾期时间，导致大量数据在同一时间失效。
  
• Redis 实例宕机，导致所有缓存失效。
  

3.2 缓存雪崩的缘故因由

• 缓存会合失效：缓存中的数据设置了雷同的逾期时间。
  
• Redis 实例宕机：Redis 服务不可用，导致所有缓存失效。
  
• 热门数据失效：某些热门数据的缓存失效，导致大量哀求直接访问数据库。
  

3.3 缓存雪崩的办理方案

3.3.1 设置随机逾期时间

为缓存数据设置随机的逾期时间，制止大量缓存数据在同一时间失效。

1. import redis.clients.jedis.Jedis;
2. import java.util.Random;
4. public class CacheAvalanche {
5.     private Jedis redis;
6.     private Database db;
7.     private Random random = new Random();
9.     public CacheAvalanche(Jedis redis, Database db) {
10.         this.redis = redis;
11.         this.db = db;
12.     }
14.     public void setCache(String key, String value) {
15.         int expireTime = 3600 + random.nextInt(600); // 过期时间在 1 小时到 1 小时 10 分钟之间
16.         redis.setex(key, expireTime, value);
17.     }
18. }

复制代码

3.3.2 多级缓存

使用多级缓存架构（如本地缓存 + Redis 缓存），即使 Redis 缓存失效，本地缓存仍旧可以提供服务。

1. import redis.clients.jedis.Jedis;
2. import java.util.Map;
3. import java.util.concurrent.ConcurrentHashMap;
5. public class CacheAvalanche {
6.     private Jedis redis;
7.     private Database db;
8.     private Map<String, String> localCache = new ConcurrentHashMap<>();
10.     public CacheAvalanche(Jedis redis, Database db) {
11.         this.redis = redis;
12.         this.db = db;
13.     }
15.     public String getData(String key) {
16.         // 先从本地缓存获取
17.         String data = localCache.get(key);
18.         if (data != null) {
19.             return data;
20.         }
21.         // 再从 Redis 缓存获取
22.         data = redis.get(key);
23.         if (data != null) {
24.             localCache.put(key, data); // 更新本地缓存
25.             return data;
26.         }
27.         // 最后从数据库获取
28.         data = db.query(key);
29.         if (data != null) {
30.             redis.setex(key, 3600, data); // 更新 Redis 缓存
31.             localCache.put(key, data); // 更新本地缓存
32.         }
33.         return data;
34.     }
35. }

复制代码

3.3.3 限流与降级

在缓存雪崩发生时，通过限流和降级机制保护数据库。比方，使用限流工具（如 Redis 的 INCR 下令）限制哀求速率，大概返回默认值或错误页面。

1. import redis.clients.jedis.Jedis;
3. public class CacheAvalanche {
4.     private Jedis redis;
5.     private Database db;
7.     public CacheAvalanche(Jedis redis, Database db) {
8.         this.redis = redis;
9.         this.db = db;
10.     }
12.     public String getData(String key) {
13.         // 限流：每秒最多处理 100 个请求
14.         if (redis.incr("request_rate") > 100) {
15.             return "Too many requests, please try again later.";
16.         }
17.         // 其他逻辑...
18.         return null;
19.     }
20. }

复制代码

---

4. 缓存穿透、缓存击穿与缓存雪崩的区别

特性缓存穿透缓存击穿缓存雪崩界说查询不存在的数据，导致哀求直接访问数据库热门数据缓存失效，导致大量哀求直接访问数据库大量缓存数据在同一时间失效，导致哀求直接访问数据库缘故因由恶意攻击或业务逻辑标题热门数据逾期或高并发哀求缓存会合失效或 Redis 实例宕机影响数据库压力过大数据库压力激增数据库压力激增以致瓦解办理方案缓存空对象、布隆过滤器、参数校验互斥锁、永不逾期 + 配景更新、缓存预热设置随机逾期时间、多级缓存、限流与降级

---

5. 最佳实践

• 公道设置缓存逾期时间：制止缓存会合失效。
  
• 使用布隆过滤器：有用防止缓存穿透。
  
• 多级缓存架构：进步体系的容错本领。
  
• 限流与降级机制：保护数据库不被压垮。
  
• 监控与报警：及时监控缓存掷中率和数据库负载，及时发现并办理标题。
  

---

6. 总结

缓存穿透、缓存击穿和缓存雪崩是 Redis 使用过程中常见的标题，它们会导致数据库压力过大以致体系瓦解。通过公道的筹划和优化，可以有用制止这些标题：

• 缓存穿透：通过缓存空对象、布隆过滤器和参数校验来办理。
  
• 缓存击穿：通过互斥锁、永不逾期 + 配景更新和缓存预热来办理。
  
• 缓存雪崩：通过设置随机逾期时间、多级缓存和限流降级来办理。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。