java-redis-击穿
Java 与 Redis 之缓存击穿问题解决方案
1. 背景：缓存的基本概念
在高并发系统中，缓存是一个非常重要的优化手段。它的基本思想是将热点数据缓存在高速的存储系统（如 Redis、Memcached）中，从而减轻数据库等持久层的压力，并加快请求响应速度。
常见的缓存模式有：
- 缓存读写：读取数据时优先从缓存中获取，如果缓存中没有数据，则从数据库或其他持久化存储中获取并缓存。
- 缓存失效策略：缓存系统通常会为每条缓存设置过期时间（TTL），过期后数据会从缓存中删除，避免数据长期过期。
2. 缓存击穿的概念
缓存击穿（Cache Breakdown）是指缓存中某些高并发访问的数据在失效的瞬间，大量请求同时穿透缓存直接访问数据库的情况。由于这些数据是热点数据，短时间内大量请求集中访问数据库，容易导致数据库过载，甚至宕机。
缓存击穿的触发场景通常是：
- 缓存数据有明确的过期时间（TTL）。
- 热点数据在缓存失效后，瞬间有大量请求同时发起读取操作。
区别于其他缓存问题：
- 缓存穿透：请求的数据在数据库中不存在，直接穿透缓存，访问数据库。
- 缓存雪崩：大量缓存同时失效，导致大量请求直接访问数据库，可能引发雪崩效应。
3. 缓存击穿的解决方案
为了避免缓存击穿问题，我们需要在缓存失效时控制多个并发请求直接访问数据库的情况。常用的解决方案包括：
- 互斥锁：为某个热点数据设置一个锁，当第一个请求获取数据时，其他请求等待，数据更新后释放锁。
- 缓存预热：在数据过期之前，提前主动刷新缓存，避免数据过期导致的瞬时压力。
- 逻辑过期：缓存中的数据设置逻辑过期标志，定期异步更新数据，避免高并发下的缓存失效。
- 过期自动更新：使用定时任务，在缓存失效前重新加载数据，确保缓存中的数据始终有效。
4. 方案一：互斥锁解决缓存击穿
**互斥锁（Mutex）**是解决缓存击穿最常见的办法。当某个缓存失效时，第一个请求负责加载数据并重新设置缓存，其他请求等待数据加载完成后直接返回缓存结果。
4.1. 基本流程
- 请求到达，尝试读取缓存。
- 如果缓存中有数据，直接返回。
- 如果缓存没有数据，使用互斥锁保证只有一个线程能够从数据库获取数据，其他请求等待。
- 获取到数据的线程更新缓存，并释放锁。
- 其他请求重新读取缓存。
4.2. 代码实现
下面是一个基于 Redis 实现互斥锁的缓存击穿解决方案。我们使用 Java 的 Redis 客户端（Jedis）来进行 Redis 操作，并利用 Redis 的 SETNX（set if not exists）来实现分布式锁。
import redis.clients.jedis.Jedis;
public class CacheService {
private Jedis jedis;
public CacheService(Jedis jedis) {
this.jedis = jedis;
}
// 获取数据的方法，包含缓存逻辑
public String getData(String key) {
// 尝试从 Redis 缓存中获取数据
String value = jedis.get(key);
if (value == null) {
// 缓存中没有数据，进入加载流程
String lockKey = "lock:" + key;
// 尝试加锁，避免缓存击穿
if (tryLock(lockKey)) {
try {
// 模拟从数据库加载数据
value = loadFromDB(key);
// 将数据写入缓存，并设置超时时间
jedis.setex(key, 300, value);
} finally {
// 释放锁
releaseLock(lockKey);
}
} else {
// 获取锁失败，等待其他线程更新缓存
try {
// 等待一段时间再尝试获取缓存
Thread.sleep(100);
return jedis.get(key); // 再次从缓存获取
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
return value;
}
// 尝试获取锁
private boolean tryLock(String lockKey) {
// 使用 Redis 的 SETNX 设置锁，成功返回1，失败返回0
String result = jedis.set(lockKey, "1", "NX", "EX", 10); // 锁过期时间为10秒
return "OK".equals(result);
}
// 释放锁
private void releaseLock(String lockKey) {
jedis.del(lockKey); // 删除锁
}
// 模拟从数据库加载数据
private String loadFromDB(String key) {
System.out.println("Loading data from DB for key: " + key);
return "DBValueFor" + key;
}
}
4.3. 互斥锁的优点和缺点
- 优点：
- 简单有效，确保在缓存失效时只有一个请求访问数据库，避免并发访问造成的数据库压力。 - 缺点：
- 可能会出现锁等待时间过长的问题，特别是在加载数据耗时较多的场景中，其他请求需要等待锁释放。
5. 方案二：逻辑过期解决缓存击穿
逻辑过期是一种延长缓存有效期的方式。我们并不真正删除缓存，而是将缓存数据设置为逻辑过期状态。每次读取缓存时，仍然返回数据，但异步刷新缓存中的数据。
5.1. 基本流程
- 请求到达，读取缓存中的数据。
- 如果缓存中的数据未过期，直接返回。
- 如果缓存数据过期，异步从数据库更新缓存，但仍返回旧的缓存数据给当前请求。
5.2. 代码实现
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class LogicalExpireCacheService {
private Jedis jedis;
private ExecutorService executorService = Executors.newFixedThreadPool(10);
public LogicalExpireCacheService(Jedis jedis) {
this.jedis = jedis;
}
// 获取数据的方法，包含逻辑过期处理
public String getData(String key) {
// 尝试从 Redis 缓存中获取数据
String cacheData = jedis.get(key);
if (cacheData != null && !isExpired(cacheData)) {
return cacheData; // 如果缓存未过期，直接返回
}
// 如果缓存过期，异步更新缓存
executorService.submit(() -> {
String newValue = loadFromDB(key);
jedis.set(key, newValue);
});
// 返回旧数据，避免直接击穿数据库
return cacheData;
}
// 检查缓存数据是否过期（模拟逻辑过期）
private boolean isExpired(String cacheData) {
// 解析数据的过期标志，这里可以自定义逻辑
return false; // 简化示例，不真正实现
}
// 模拟从数据库加载数据
private String loadFromDB(String key) {
System.out.println("Loading data from DB for key: " + key);
return "NewDBValueFor" + key;
}
}
5.3. 逻辑过期的优点和缺点
-
优点：
- 不会阻塞用户请求，哪怕缓存过期，用户仍能拿到旧的数据。
- 适合对时效性要求不高的场景。 -
缺点：
- 异步更新缓存的过程存在时间差，可能导致部分用户获取的是旧数据。
- 数据一致性要求较高时需要谨慎使用。
6. 方案三：缓存预热
缓存预热指的是在缓存数据即将失效之前，主动更新缓存数据，避免缓存过期瞬间的大量并发请求击穿缓存。
6.1. 基本流程
- 定期提前刷新缓存，在缓存过期前将新数据写入缓存。
- 使用定时任务或后台线程进行缓存的预加载和刷新，确保热点数据始终在缓存中。
6.2. 实现方式
通过 Spring 的定时任务机制或其他调度工具，定期刷新热点数据的缓存。例如：
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
@Service
public class CachePreheatService {
private Jedis jedis;
public CachePreheatService(Jedis jedis) {
this.jedis = jedis;
}
// 定时任务，每隔 5 分钟刷新缓存
@Scheduled(fixedRate = 300000)
public void
refreshCache() {
String key = "hotDataKey";
String value = loadFromDB(key);
jedis.set(key, value);
System.out.println("Cache refreshed for key: " + key);
}
// 模拟从数据库加载数据
private String loadFromDB(String key) {
System.out.println("Loading data from DB for key: " + key);
return "PreheatedDBValueFor" + key;
}
}
6.3. 优点和缺点
- 优点：
- 通过提前刷新缓存，避免缓存失效时的大量并发请求，确保热点数据始终存在缓存中。 - 缺点：
- 需要额外的调度管理和计算热点数据，不能解决所有场景下的缓存击穿问题。
7. 总结
缓存击穿是高并发系统中一个常见且重要的问题。针对不同的业务场景，我们可以采取多种措施来应对缓存击穿，如互斥锁、逻辑过期、缓存预热等。
- 互斥锁：确保缓存失效时只有一个线程能够访问数据库，适合数据一致性要求较高的场景。
- 逻辑过期：返回旧缓存数据并异步更新缓存，适合对时效性要求不高的场景。
- 缓存预热：提前刷新缓存，避免热点数据在缓存失效时被大量请求穿透。
这些策略可以结合使用，根据不同的业务场景和性能要求，选择最合适的方案，确保系统在高并发场景下的稳定性。