个人技术分享

缓存穿透

现象

缓存穿透指的是用户请求的数据在缓存层和存储层都不存在，这种情况下，请求会穿透缓存直接访问存储层，导致存储层压力过大。如果有人恶意请求大量不存在的数据，缓存穿透会对系统造成严重影响。

解决方案

1. 布隆过滤器

   布隆过滤器是一种空间效率很高的数据结构，可以用来快速判断一个元素是否在一个集合中。将所有可能的请求 key 存入布隆过滤器，请求来临时先通过布隆过滤器判断，如果布隆过滤器判断 key 不存在，直接返回，不再访问缓存层和存储层。

   // 初始化布隆过滤器，假设有 1000 万个可能的 key，误判率为 0.01%
   BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 10000000, 0.0001);
   
   // 将所有可能的 key 添加到布隆过滤器中
   for (String key : allPossibleKeys) {
       bloomFilter.put(key);
   }
   
   // 查询时先判断布隆过滤器
   String key = "someKey";
   if (!bloomFilter.mightContain(key)) {
       // key 不存在，直接返回
       return null;
   }
   
   // key 可能存在，查询缓存和存储层
   String value = redis.get(key);
   if (value == null) {
       value = db.get(key);
       if (value != null) {
           redis.set(key, value);
       }
   }
   

2. 缓存空对象

   对于查询结果为空的数据，可以在缓存中存储一个空对象或特殊值（例如 "NULL"），设置较短的过期时间。下次查询相同的 key 时，可以直接返回缓存中的空对象，避免再次访问存储层。

   String key = "someKey";
   String value = redis.get(key);
   if (value == null) {
       value = db.get(key);
       if (value == null) {
           // 数据库中不存在，缓存空对象，设置过期时间为 1 分钟
           redis.set(key, "NULL", 60);
       } else {
           redis.set(key, value);
       }
   } else if ("NULL".equals(value)) {
       // 缓存中是空对象，直接返回
       return null;
   }
   

缓存击穿

现象

缓存击穿指的是某些热点 key 在缓存过期的瞬间，有大量并发请求同时访问这些 key，导致请求直接打到存储层，给存储层带来巨大压力。

解决方案

1. 互斥锁（Mutex）

   当缓存失效时，只允许一个线程去加载数据并构建缓存，其他线程等待该线程完成后再去访问缓存。

   String key = "key1";
   String value = redis.get(key);
   if (value == null) {
       synchronized (this) {
           value = redis.get(key);
           if (value == null) {
               value = db.get(key);
               redis.set(key, value);
           }
       }
   }
   

2. 永不过期

   将热点 key 的缓存设置为永不过期，通过异步线程定期更新缓存，保证缓存和存储层数据的一致性。

   // 定期更新缓存
   @Scheduled(fixedRate = 300000) // 每 5 分钟执行一次
   public void refreshCache() {
       String key = "hotkey";
       String value = db.get(key);
       redis.set(key, value);
   }
   

缓存雪崩

现象

缓存雪崩指的是缓存层由于某些原因（如大量缓存同时过期、缓存服务器宕机等）导致大面积的缓存不可用，所有请求都直接打到存储层，导致存储层压力过大甚至宕机。

解决方案

1. 缓存过期时间分散

   设置缓存过期时间时，增加一个随机值，避免大量缓存数据在同一时间点失效。

   int baseExpireTime = 600; // 基础过期时间 10 分钟
   int randomExpireTime = new Random().nextInt(300); // 随机增加 0-5 分钟
   redis.set(key, value, baseExpireTime + randomExpireTime);
   

2. 多级缓存

   将热点数据缓存到本地 JVM 内存中作为一级缓存，Redis 作为二级缓存，降低对 Redis 的依赖。

   LoadingCache<String, String> localCache = Caffeine.newBuilder()
       .maximumSize(1000)
       .expireAfterWrite(10, TimeUnit.MINUTES)
       .build(new CacheLoader<String, String>() {
           @Override
           public String load(String key) throws Exception {
               return redisTemplate.opsForValue().get(key);
           }
       });
   

3. 服务降级与限流

   使用服务治理框架如 Sentinel 设置降级策略，当缓存层不可用时，通过降级策略返回默认值或提示服务繁忙，避免请求打到存储层。

   // 配置限流规则
   FlowRule rule = new FlowRule();
   rule.setResource("getResource");
   rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
   rule.setCount(100); // 每秒最多 100 个请求
   FlowRuleManager.loadRules(Collections.singletonList(rule));
   

热点 Key

现象

热点 Key 指的是访问频率特别高的 Key。热点 Key 的存在会导致缓存和存储层的压力集中，影响系统性能。

解决方案

1. 二级缓存

   将热点 Key 的数据加载到本地 JVM 内存中作为一级缓存，减轻 Redis 的压力。

   LoadingCache<String, String> localCache = Caffeine.newBuilder()
       .maximumSize(1000)
       .expireAfterWrite(10, TimeUnit.MINUTES)
       .build(new CacheLoader<String, String>() {
           @Override
           public String load(String key) throws Exception {
               return redisTemplate.opsForValue().get(key);
           }
       });
   

2. Key 分散

   将热点 Key 分散为多个子 Key，存储在不同的缓存节点上，通过一致性哈希算法均衡各节点压力。

   int shardCount = 10; // 分片数量
   String baseKey = "hotkey:";
   int hash = Math.abs(key.hashCode()) % shardCount;
   String shardKey = baseKey + hash;
   

BigKey

现象

BigKey 指的是在 Redis 中占用内存较大的 Key。BigKey 的存在会导致内存使用不均匀、操作超时、网络拥塞等问题。

解决方案

1. 拆分 BigKey

   将 BigKey 的数据拆分为多个小 Key，分别存储在 Redis 中，减小单个 Key 的数据量。

   int pageSize = 100;
   for (int i = 0; i < bigList.size(); i += pageSize) {
       List<String> subList = bigList.subList(i, Math.min(i + pageSize, bigList.size()));
       redisTemplate.opsForList().rightPushAll("bigkey:" + i / pageSize, subList);
   }
   

2. 定期清理 BigKey

   定期检查和清理 Redis 中的 BigKey，避免其占用过多内存。

   @Scheduled(fixedRate = 3600000) // 每小时执行一次
   public void cleanBigKeys() {
       Set<String> keys = redisTemplate.keys("*");
       for (String key : keys) {
           Long size = redisTemplate.opsForValue().size(key);
           if (size != null && size > BIG_KEY_THRESHOLD) {
               redisTemplate.delete(key);
           }
       }
   }
   

3. 使用压缩算法

   对 BigKey 的数据进行压缩，减小其占用的内存空间。

   byte[] compressedData = Snappy.compress(bigKeyData.getBytes());
   redisTemplate.opsForValue().set("bigkey", compressedData);
   

总结

通过合理的缓存设计和优化策略，可以有效解决缓存穿透、缓存击穿、缓存雪崩、热点 Key 和 BigKey 等问题，提高系统的高可用性和性能。采用布隆过滤器、二级缓存、互斥锁、分散过期时间、分片等技术手段，可以大大提升 Redis 缓存的稳定性和响应速度，从而保证系统的高效运行。