目录
介绍
缓存穿透
缓存击穿
缓存雪崩
原因
影响
解决方案
缓存穿透
防止缓存穿透->空值缓存案例
缓存击穿
使用互斥锁解决缓存击穿
介绍
缓存穿透
定义：缓存穿透是指用户查询数据，缓存和数据库中都不存在该数据（一般是发起恶意的查询，试图击穿缓存，直接查询数据库），这时用户每次查询都会直接打到数据库上，而数据库中也没有该数据，如果用户不断发起这样的请求，数据库压力会非常大，甚至可能拖垮数据库。
解决方案：
- 布隆过滤器（Bloom Filter）：布隆过滤器可以快速判断一个元素是否在一个集合中，但是会有一定的误判率。在数据放入缓存之前，先使用布隆过滤器判断数据是否存在，如果不存在则直接返回，不进行数据库查询。
- 空值缓存：对于不存在的数据，也在缓存中存放一个空值（或者一个特殊标记），这样下次查询相同的数据时，可以直接返回缓存中的空值，避免了对数据库的查询。但是这种方法需要设置合理的过期时间，避免数据长时间不更新。
- 请求限流：对查询请求进行限流，限制查询频率，防止恶意查询。
缓存击穿
定义：缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。
解决方案：
- 设置热点数据永不过期，即逻辑缓存：对于一些热点数据，可以将其设置为永不过期，从而避免缓存击穿问题。但是这种方法会占用较多的缓存空间，需要谨慎使用。
- 加互斥锁：在查询数据库之前，先尝试获取一个分布式锁，如果获取到锁，则查询数据库并更新缓存；如果未获取到锁，则等待一段时间后重试。这样可以保证同一时间只有一个请求去查询数据库，从而减轻数据库压力。
- 双缓存策略：使用两个缓存，一个缓存的过期时间较短，用于应对大部分请求；另一个缓存的过期时间较长，用于应对缓存击穿的情况。当短缓存过期时，先从长缓存中获取数据，然后再去查询数据库并更新两个缓存。
缓存雪崩
缓存雪崩是指在缓存中存储的大量数据同时失效或过期，导致缓存系统无法承载大量请求压力，造成服务宕机甚至瘫痪的情况。这种情况下，大量的请求会直接涌入数据库，导致数据库崩溃或响应缓慢，影响应用程序的正常使用。
原因
缓存雪崩通常由于以下几个原因引起：
- 缓存过期策略：如果大量的缓存数据被设置为相同的过期时间，那么在这些数据同时过期时，就会引发缓存雪崩。
- 缓存服务器故障：当缓存服务器（如Redis）宕机或网络中断时，缓存服务将不可用，所有请求都会直接打到数据库上。
- 大量突发请求：在特定时间段内，如果请求量激增且超出缓存系统的处理能力，也可能导致缓存雪崩。
影响
缓存雪崩的影响是灾难性的，主要包括以下几个方面：
- 数据库负载过高：大量的请求直接打到数据库上，导致数据库负载急剧增加，响应时间延长。
- 服务不可用：在极端情况下，数据库可能因为压力过大而崩溃，导致整个服务不可用。
- 性能瓶颈：数据库成为瓶颈，系统整体处理能力下降，用户体验受到严重影响。
- 连锁反应：由于服务间的依赖关系，缓存雪崩可能导致多个服务相继瘫痪，形成连锁反应。
解决方案
为了防范和应对缓存雪崩，可以采取以下策略：
- 设置随机过期时间：为不同的缓存数据设置随机的过期时间，避免大量数据同时过期。
- 限流和熔断：当检测到缓存系统压力过大时，通过限流组件限制请求量，并在必要时采取熔断措施，如返回默认数据或静态页面。
- 主动更新缓存：在缓存失效前，主动提前重新加载数据至缓存，以减轻数据库压力。
- 加锁机制：当缓存失效后，通过加锁机制控制只有一个线程负责从数据库加载数据并回填缓存，其他线程等待或返回旧数据。
- 部署缓存集群：部署Redis Sentinel或Cluster集群等缓存集群方案，确保单点故障时能自动切换到其他节点。
- 使用布隆过滤器：在缓存之前使用布隆过滤器判断请求的键是否存在，减少对数据库的无效访问。
缓存穿透
缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库。给数据库带来巨大压力
常见的解决方案有两种：
缓存空对象
- 优点：实现简单，维护方便
- 缺点：额外的内存消耗 可能造成短期的不一致
布隆过滤
优点：内存占用较少，没有多余key
缺点：实现复杂 存在误判可能
还有的解决方案：主动性的方案
- 增强id的复杂性，避免被猜测id规律
- 做好数据的基础格式校验
- 加强用户权限校验
- 做好热点参数的限流
防止缓存穿透->空值缓存案例
public Shop queryWithPassThrough(Long id) {
String key = CACHE_SHOP_KEY + id;
Map<Object, Object> shopFromCache = stringRedisTemplate.opsForHash().entries(key);
System.out.println("Redis: " + shopFromCache);
// 检查 Redis 返回的 shopFromCache 是否为 null
if (shopFromCache != null && !shopFromCache.isEmpty()) {
// 缓存中有值，尝试反序列化 Shop 对象
Shop shopFromCacheBean = BeanUtil.fillBeanWithMap(shopFromCache, new Shop(), false);
return shopFromCacheBean;
}
// Redis 中不存在，从数据库中查询
Shop shopFromDb = baseMapper.selectById(id);
// 数据库中也不存在，则缓存空值以防缓存穿透
if (ObjectUtil.isNull(shopFromDb)) {
stringRedisTemplate.opsForHash().put(key, CACHE_SHOP_EMPTY_KEY, CACHE_SHOP_EMPTY_VALUE); // 使用特殊标记表示空值
stringRedisTemplate.expire(key, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return null;
}
// 将 Shop 对象转换为 Map 并写入 Redis
Map<String, Object> shopMap = BeanUtil.beanToMap(shopFromDb, new HashMap<>(),
CopyOptions.create().ignoreNullValue()
.setFieldValueEditor((fieldName, fieldValue) -> fieldValue != null ? fieldValue.toString() : null));
stringRedisTemplate.opsForHash().putAll(key, shopMap);
// 设置超时时间
stringRedisTemplate.expire(key, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shopFromDb;
}
缓存击穿
缓存击穿问题也叫热点key问题，就是一个被高并发访问并且缓存重建业务复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击
解决方案 优点 缺点
互斥锁 没有额外的内存消耗 线程需要等待，性能受影响
保证一致性 可能有死锁风险
实现简单
逻辑过期 线程无需等待，性能较好 不保证一致性
有额外内存消耗
实现复杂
使用互斥锁解决缓存击穿
@Override
public Result queryById(Long id) throws InterruptedException {
// 缓存穿透
// queryWithPassThrough(id);
// 互斥锁解决缓存击穿
Shop shop = queryWithMutex(id);
if (shop==null) {
return Result.fail("商品不存在");
}
return Result.ok(shop);
}
public Shop queryWithMutex(Long id) throws InterruptedException {
String key = CACHE_SHOP_KEY + id;
Map<Object, Object> shopFromCache = stringRedisTemplate.opsForHash().entries(key);
System.out.println("Redis: " + shopFromCache);
// 检查 Redis 返回的 shopFromCache 是否为 null
if (shopFromCache != null && !shopFromCache.isEmpty()) {
// 缓存中有值，尝试反序列化 Shop 对象
Shop shopFromCacheBean = BeanUtil.fillBeanWithMap(shopFromCache, new Shop(), false);
return shopFromCacheBean;
}
// Redis 中不存在，从数据库中查询
// 4.实现缓存重建
// 4.1获取互斥锁
// 4.2获取失败，休眠然后重试
// 4.3获取成功，返回数据，释放锁
Shop shopFromDb=null;
try {
boolean isLock = tryLock(LOCK_SHOP_KEY + id);
if (!isLock) {
// 拿不到锁，休眠，然后递归不断尝试
// 这个返回结果会是在redis里拿到的数据
Thread.sleep(50);
return queryWithMutex(id);
}
// 拿到互斥锁，查询数据库，重建缓存
shopFromDb= baseMapper.selectById(id);
// 模拟重建延迟
Thread.sleep(200);
// 数据库中也不存在，则缓存空值以防缓存穿透
stringRedisTemplate.opsForHash().put(key, CACHE_SHOP_EMPTY_KEY, CACHE_SHOP_EMPTY_VALUE); // 使用特殊标记表示空值
stringRedisTemplate.expire(key, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
return null;
}
// 将 Shop 对象转换为 Map 并写入 Redis
Map<String, Object> shopMap = BeanUtil.beanToMap(shopFromDb, new HashMap<>(),
CopyOptions.create().ignoreNullValue()
.setFieldValueEditor((fieldName, fieldValue) -> fieldValue != null ? fieldValue.toString() : null));
stringRedisTemplate.opsForHash().putAll(key, shopMap);
// 设置超时时间
stringRedisTemplate.expire(key, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
// 释放锁
unLock(LOCK_SHOP_KEY + id);
}
return shopFromDb;
}public boolean tryLock(String key) {
Boolean b = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(b);
}
public void unLock(String key) {
stringRedisTemplate.delete(key);
}
