【缓存】之缓存失效（OutOfDirectMemoryError异常处理）

本篇记录来自b站——尚硅谷

（一）缓存

（1）缓存的使用

哪些数据适合放入缓存？

1. 即时性、数据一致性要求不高的
2. 访问量大且更新频率不高的数据（读多，写少）

如：电商类应用的商品分类，商品列表等适合缓存并加一个失效时间（根据数据的更新频率来定），后台如果发布一个商品，买家需要5分钟才能看到新的商品，一般还是可以接受的。

读模式缓存使用流程

（2）SpringBoot整合redis作为缓存

1. springboot将redis抽取成场景启动器，也即相应的starters

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 加入缓存逻辑，缓存中存的数据是json字符串，因为json跨语言的，跨平台的兼容。如果php需要获取这个数据，也能够进行处理。
   
   将对象转换为json放在缓存中，这里涉及对象转换为String ，再将json数据转换为对象。使用的是com.alibaba.fastjson包

//法一
String s1 = JSON.toJSON(payChannelParamsDTOs).toString(); //将查询到的list转换为字符串，存入缓存
List<PayChannelParamsDTO> payChannelParamsDTOs = JSON.parseArray(PayChannelParamDTO_String, PayChannelParamsDTO.class); // 取出缓存中的数据（PayChannelParamDTO_String是一个list）转换为需要的类型。

//法二
String s2 = JSON.toJSONString(catalogJsonFromDb); //将数据转换为字符串
Map<String, List<Catelog2Vo>>  result = JSON.parseObject(catalogJsonFromDb, new TypeReference<Map<String, List<Catelog2Vo>>>(){}); // redis中获取到的数据（catalogJsonFromDb）转换为指定类型,使用TypeReference

（3）堆外内存溢出及疑问

OutOfDirectMemoryError

1. 错误报告
   
2. 原因
   springboot2.0以后默认使用lettuce作为操作redis的客户端。它使用netty进行网络通信。
   
   lettuce的bug导致netty堆外内存溢出 -Xmx300m（本例测试时手动设置了最大堆内存）；netty如果没有指定堆外内存，默认使用 -Xmx300m(即自己手动设置的)。
   不能使用-Dio.netty.maxDirectMemory只去调大堆外内存
3. 解决方案
   (1) 升级lettuce客户端
   (2)切换使用jedis

这里使用第二种解决方案

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

4. redisTemplate客户端和lettuce客户端

• springboot中，我们明明使用的是redisTemplate作为操作redis的客户端，但我们又说redis底层用lettuce和jedis，他们之间是什么关系呢?
• lettuce、jedis是操作redis的底层客户端。Spring再次封装redisTemplate，我们使用redisTemplate操作redis，不需要了解它的底层使用的是lettuce还是jedis。
• redis的自动配置类也能看到对lettuce和jedis的封装
  

（二）缓存失效

（1）缓存雪崩

1. 出现原因
   
   瞬间过期数据量太大，导致对数据库服务器造成压力。简单的理解：由于原有缓存失效，新缓存未到期间所有原本应该访问缓存的请求都去查询数据库了，而对数据库CPU和内存造成巨大压力，严重的会造成数据库宕机。从而形成一系列连锁反应，造成整个系统崩溃。
   
   比如：缓存中有1000个商品，他们设置了相同的过期时间，时间到了，全部同时过期。等请求进入,访问这些商品，全部不存在，都去访问数据库了，就导致了数据库宕机。

2. 解决
   
   原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件（其实，这个也有问题，如果一开始过期时间不同，一个2min，一个3min，取随机值后一个加2，一个加1，反而变的相同了）

（2）缓存击穿

1. 出现原因
   
   对于某些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常热点的数据。如果这个key在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db

2. 解决
   
   加锁。大量并发只让一个去查，其他人等待，查到以后释放锁，其他人获取到锁，先查缓存，就会有数据，不用去db

（3）缓存穿透

1. 出现原因
   
   查询一个一定不存在的数据，由于缓存不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询到的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义，也对数据库服务器造成压力。
2. 解决
   
   null结果缓存，并加入短暂的过期时间。判断redis无结果，且同时数据库无结果，再将该值为null存入缓存中。
   
   最好的解决方案是布隆过滤器，我暂时还没学过，之后用到了再了解。

（4）结合实例优化

1. 未经优化的代码
   

String catelogJSON = redisTemplate.opsForValue().get("catelogJSON"); //1.取缓存中存入的数据
if(StringUtils.isEmpty(catelogJSON )){
    //2. 缓存中没有，查询数据库
    Map<String, List<Catelog2Vo>> catalogJsonFromDb = getCatelogJsonFromDb();
    //3. 查询到的数据，再放入缓存
    String s2 = JSON.toJSONString(catalogJsonFromDb );
    redisTemplate.opsForvalue().set("catelogJSON");
    return catalogJsonFromDb ;
}

2. 优化后的代码
   
   锁带来的时序问题，查数据库及放入缓存要是原子操作，即放入同一个锁中

/**
** 1.空结果缓存：解决缓存穿透
** 2.设置过期时间（加随机值）：解决缓存雪崩
** 3.加锁：解决缓存击穿
*/
String catelogJSON = redisTemplate.opsForValue().get("catelogJSON");
if(StringUtils.isEmpty(catelogJSON )){
  // 缓存中没有，查询数据库
  Map<String, List<Catelog2Vo>> catalogJsonFromDb = getCatelogJsonFromDb();
  return catalogJsonFromDb ;
}

public Map<String, List<Catelog2Vo>> getCatelogJsonFromDb(){
   
    //只要是同一把锁，就能锁住需要这个锁的所有线程
    //1.synchronized(this):SpringBoot所有的组件在容器中都是单例的。这个类只对了一个锁，
	synchronized(this){
	
	//得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
	String catelogJSON = redisTemplate.opsForValue().get("catelogJSON");
	List<categoryEntity> selectList = baseMapper.selectList(null);
	
	//缓存不为null，直接返回
	if(!StringUtils.isEmpty(catelogJSON )){
	  Map<String, List<Catelog2Vo>> result = JSON.parseObject(catelogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>{});  //将结果转换为对象
	  return result;
	}

   //================查询数据库，封装结果======================
   
   //3.查到的数据再放入缓存，将对象转为json放在缓存中
   String s = JSON.toJSONString(catelog2Vos);  //catelog2Vos即查询出来的结果
   redisTemplate.opsForValue().set("catelogJSON", s, 1, TimeUnit.Days); //保存到缓存，并设置过期时间
   return catelog2Vos;
	}
}

3. 总结
   
   加锁解决缓存击穿问题，本例中使用的是本地锁synchronized(this) //this(锁对象)，只能锁住当前对象，当一个服务启动多个实例，就不行了。