缓存击穿
什么是缓存击穿
缓存击穿是指在缓存中某个热点数据失效的瞬间，有大量并发请求同时访问该数据，这些请求绕过缓存直接查询数据库或其他持久化存储，从而导致数据库或持久化存储的瞬时压力骤增，可能会影响系统的稳定性和性能。
缓存击穿的原因
- 热点数据失效: 缓存中的热点数据（被频繁访问的数据）到达过期时间失效。
- 高并发访问: 在数据失效的瞬间，有大量并发请求访问该数据。
示例
假设有一个电商网站，其中某个商品的详情页是一个热点数据，缓存有效期为10分钟。这个商品非常受欢迎，可能会有大量用户在同一时间访问该详情页。
情景
-
缓存有效期内:
- 商品详情数据被缓存，所有请求都从缓存中读取，数据库压力较小。
用户请求 --> 缓存（命中） --> 返回商品详情 -
缓存失效瞬间:
- 缓存到期失效，有大量用户同时访问该商品详情页，由于缓存中没有数据，这些请求直接访问数据库。
用户请求 --> 缓存（未命中） --> 数据库（大量并发访问）
结果
数据库瞬时压力骤增，可能会导致响应变慢，甚至数据库崩溃，影响整个系统的稳定性和性能。
解决缓存击穿的三种方法
1. 查询缓存不存在请求数据库
当查询缓存时发现数据不存在，直接访问数据库获取数据，并将数据重新加载到缓存中。这种方法比较简单直接，但在高并发情况下，可能会导致大量请求同时访问数据库，压力骤增。
示例代码
以下是一个使用查询缓存不存在请求数据库的方法的 Java 代码示例：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class CacheService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
private static final String CACHE_KEY = "cache_key";
public String getData(String key) {
// 查询缓存
String value = stringRedisTemplate.opsForValue().get(CACHE_KEY + key);
if (value != null) {
return value;
}
// 缓存中不存在数据，请求数据库
value = loadDataFromDatabase(key);
// 更新缓存
stringRedisTemplate.opsForValue().set(CACHE_KEY + key, value, 10, TimeUnit.MINUTES);
return value;
}
private String loadDataFromDatabase(String key) {
// 模拟数据库操作
return "data_from_database";
}
}
代码解释
-
查询缓存：
使用stringRedisTemplate.opsForValue().get(CACHE_KEY + key)从缓存中获取数据。
如果数据存在，则直接返回。 -
请求数据库：
如果缓存中数据不存在，则调用loadDataFromDatabase(key)方法从数据库获取数据。 -
更新缓存：
将从数据库获取的数据使用stringRedisTemplate.opsForValue().set(CACHE_KEY + key, value, 10, TimeUnit.MINUTES)方法重新加载到缓存中，并设置缓存的过期时间。
优点和缺点
优点：
- 实现简单，易于理解和维护。
缺点：
- 在高并发情况下，可能会导致大量请求同时访问数据库，压力骤增，影响数据库性能。
2. 分布式互斥锁优化数据库压力
通过分布式锁机制确保在高并发情况下，只有一个请求能够访问数据库并加载数据，其他请求需等待该请求完成后再从缓存读取数据。这样可以显著减少数据库的并发访问量，降低数据库压力。
示例代码
以下是一个使用分布式互斥锁的方法的 Java 代码示例：
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class CacheService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedissonClient redissonClient;
private static final String CACHE_KEY = "cache_key";
private static final String LOCK_KEY = "lock_key";
public String getData(String key) {
// 查询缓存
String value = stringRedisTemplate.opsForValue().get(CACHE_KEY + key);
if (value != null) {
return value;
}
// 获取分布式锁
RLock lock = redissonClient.getLock(LOCK_KEY + key);
lock.lock(10, TimeUnit.SECONDS); // 设置锁的超时时间
try {
// 再次检查缓存，防止在获取锁的过程中其他请求已经加载了数据并更新了缓存
value = stringRedisTemplate.opsForValue().get(CACHE_KEY + key);
if (value != null) {
return value;
}
// 缓存中不存在数据，请求数据库
value = loadDataFromDatabase(key);
// 更新缓存
stringRedisTemplate.opsForValue().set(CACHE_KEY + key, value, 10, TimeUnit.MINUTES);
} finally {
// 释放锁
lock.unlock();
}
return value;
}
private String loadDataFromDatabase(String key) {
// 模拟数据库操作
return "data_from_database";
}
}
代码解释
-
查询缓存：
- 使用 stringRedisTemplate.opsForValue().get(CACHE_KEY + key) 从缓存中获取数据。
- 如果数据存在，则直接返回。
-
获取分布式锁：
- 如果缓存中数据不存在，则使用 RedissonClient 获取一个分布式锁对象，并尝试获取锁。
- 设置锁的超时时间为10秒，确保锁不会长时间占用。
-
再次检查缓存：
- 在获取锁后，再次从缓存中获取数据，防止在获取锁的过程中其他请求已经加载了数据并更新了缓存。
- 如果数据存在，则直接返回。
-
请求数据库：
- 如果缓存中数据仍然不存在，则调用 loadDataFromDatabase(key) 方法从数据库获取数据。
-
更新缓存：
- 将从数据库获取的数据使用 stringRedisTemplate.opsForValue().set(CACHE_KEY + key, value, 10, TimeUnit.MINUTES) 方法重新加载到缓存中，并设置缓存的过期时间。
-
释放锁：
- 最后，使用 lock.unlock() 释放分布式锁。
优点和缺点
优点：
- 有效减少数据库的并发访问量，降低数据库压力。
- 防止缓存击穿，保证系统稳定性。
缺点：
- 实现稍微复杂，需要依赖分布式锁机制。
3. 双重判定锁
双重判定锁结合了双重检查和分布式锁的优点。第一次检查缓存，如果数据不存在，则获取分布式锁；在获取锁后再次检查缓存，如果数据仍然不存在，再访问数据库加载数据，并更新缓存。这样可以有效防止缓存击穿，并减少不必要的数据库访问。
示例代码
以下是一个使用双重判定锁的方法的 Java 代码示例：
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class CacheService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedissonClient redissonClient;
private static final String CACHE_KEY = "cache_key";
private static final String LOCK_KEY = "lock_key";
public String getData(String key) {
// 第一次检查缓存
String value = stringRedisTemplate.opsForValue().get(CACHE_KEY + key);
if (value != null) {
return value;
}
// 获取分布式锁
RLock lock = redissonClient.getLock(LOCK_KEY + key);
lock.lock(10, TimeUnit.SECONDS); // 设置锁的超时时间
try {
// 第二次检查缓存
value = stringRedisTemplate.opsForValue().get(CACHE_KEY + key);
if (value != null) {
return value;
}
// 缓存中不存在数据，请求数据库
value = loadDataFromDatabase(key);
// 更新缓存
stringRedisTemplate.opsForValue().set(CACHE_KEY + key, value, 10, TimeUnit.MINUTES);
} finally {
// 释放锁
lock.unlock();
}
return value;
}
private String loadDataFromDatabase(String key) {
// 模拟数据库操作
return "data_from_database";
}
}
代码解释
-
第一次检查缓存：
- 使用 stringRedisTemplate.opsForValue().get(CACHE_KEY + key) 从缓存中获取数据。
- 如果数据存在，则直接返回。
-
获取分布式锁：
- 如果第一次检查缓存发现数据不存在，则使用 RedissonClient 获取一个分布式锁对象，并尝试获取锁。
- 设置锁的超时时间为10秒，确保锁不会长时间占用。
-
第二次检查缓存：
- 在获取锁后，再次从缓存中获取数据，防止在获取锁的过程中其他请求已经加载了数据并更新了缓存。
- 如果数据存在，则直接返回。
-
请求数据库：
- 如果缓存中数据仍然不存在，则调用 loadDataFromDatabase(key) 方法从数据库获取数据。
-
更新缓存：
- 将从数据库获取的数据使用 stringRedisTemplate.opsForValue().set(CACHE_KEY + key, value, 10, TimeUnit.MINUTES) 方法重新加载到缓存中，并设置缓存的过期时间。
-
释放锁：
- 最后，使用 lock.unlock() 释放分布式锁。
优点和缺点
优点：
- 有效防止缓存击穿，确保在高并发情况下，只有一个请求能够访问数据库并加载数据。
- 减少数据库的并发访问量，降低数据库压力。
缺点：
- 实现复杂度较高，需要依赖分布式锁机制。
总结
这三种方法各有优缺点和适用场景。查询缓存不存在请求数据库的方法实现简单，适用于并发访问量较低或对实时性要求不高的场景。分布式互斥锁通过有效减少数据库的并发访问量，适用于高并发场景，特别是对数据库负载敏感的应用。双重判定锁结合了双重检查和分布式锁的优点，能够有效防止缓存击穿，适用于高并发和高负载的关键业务系统，特别是对系统稳定性和性能要求较高的场景。通过综合使用这些方法，可以根据不同的应用场景和需求，灵活选择和组合解决方案，有效防止缓存击穿问题，提高系统的可靠性和性能。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
