缓存(锁，redis)

缓存

本地缓存和分布式缓存

放入缓存的数据格式

• 即时性、数据一致性要求不高的
• 访问量大且更新效率不高的数据

本地缓存：放在本地内存中，先进行查询

redis依赖

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

redis本地配置方案

• 引入data-redis-starter
• 简单配置redis的host等信息
• 使用springboot自动配置好的stringRedisTemplate

//springboot2.0以后默认使用Lettuce作为操作redis的客户端，它使用netty进行了网络通信
//Letuce bug导致堆外内存溢出 -Xmx300m：netty如果没有指定堆外内存，默认使用_Xmx300m
//可以通过Dio.netty.maxDirectMemory进行设置
//解决方案：不能只使用Dio.netty.maxDirectMemoy只去调整堆外内存
//1.升级Lettuce客户端
//2.切换使用jedis

lettuce可用数据传输量较大，但是会有后台内存溢出的bug，可进行包排除引入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>

缓存击穿：

指查询一个一定不存在的数据，由于缓存是不命中，蒋去查询数据库，但数据库也无此记录，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义

风险：

利用不存在的数据进行攻击，数据库瞬间压力增大，最终导致崩溃

解决：

null结果缓存，并加入短暂过期时间

缓存雪崩

缓存雪崩是指在我们设置缓存时key采用了相同的过期时间,导致缓存在某一时刻同时失效，请求全部转发到DB,DB瞬间压力过重雪崩

解决：

原有的失效时间的基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件

缓存击穿

• 对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发的请求，是一种非常热点的数据

• 如果这个key在大量请求同时进来刚好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿

解决：

加锁

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

加锁

单节点加锁

• synchronized代码块

只要是同一把锁就能锁住需要这个锁的所有线程

synchronized(this){

}
当前对象加锁

springboot所有的组件在容器中都是单例的

或者直接在方法上加synchronized

批量数据竞争锁，当得到锁之后，我们应该再去缓存中确定一次，如果没有才需要继续查询

 public Map<String, List<Catelog2Vo>> getCatalogJson() {
        // 加入缓存逻辑,缓存中存的数据是Josn字符串,还用逆转为能用的对象类型［序列化和反序列化］
        /*解决缓存穿透
        * 空结果缓存，解决缓存穿透问题*/
        /*解决缓存雪崩
        * 设置过期时间(加随机值)，解决缓存雪崩*/
        /*解决缓存击穿
        * 加锁，解决缓存击穿*/
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");

        if (StringUtils.isEmpty(catalogJSON)){
            // 缓存中没有,查询数据库
            Map<String, List<Catelog2Vo>> catelogJsonFromDb = getCatalogJsonFromdb();
            //查询到的数据再放入缓存
            String s = JSON.toJSONString(catelogJsonFromDb);
            redisTemplate.opsForValue().set("catalogJSON",s);
            return  catelogJsonFromDb;
        }

        //转为我们指定的对象
        Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<Catelog2Vo>>>(){});
        return result;
    }

    /*从数据库查询和封装整个分类数据*/
    public Map<String, List<Catelog2Vo>> getCatalogJsonFromdb() {
        /*查询所有的一级分类*/
        synchronized (this){
            String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
            if (!StringUtils.isEmpty(catalogJSON)){
                /*缓存不为空，直接返回*/
                Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<Catelog2Vo>>>(){});
                return result;
            }
            List<CategoryEntity> level1Categorys = getLevel1Categorys();

            /*数据封装*/
            Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k ->
                    k.getCatId().toString(), v -> {
                /*拿到每一个的一级分类，查询所有一级分类的二级分类*/
                List<CategoryEntity> categoryEntitys = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
                List<Catelog2Vo> catelog2Vos = null;
                if (categoryEntitys != null) {
                    catelog2Vos = categoryEntitys.stream().map(l2 -> {
                        Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                        /*找当前二级分类的三级分类分装成ｖｏ*/
                        List<CategoryEntity> level3Catalog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", l2.getCatId()));
                        if (level3Catalog!=null){
                            List<Catelog2Vo.Category3Vo> collect = level3Catalog.stream().map(l3 -> {
                                Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo( l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                                return category3Vo;
                            }).collect(Collectors.toList());
                            catelog2Vo.setCatalog3List(collect);
                        }
                        return catelog2Vo;

                    }).collect(Collectors.toList());
                }
                return catelog2Vos;
            }));
            return parent_cid;
        }
    }

分布式加锁

分布式锁会较慢，进程锁较快

本地锁缺点，在分布式的情况下锁不住所有的服务，在分布式情况下，想要锁住所有，必须使用分布式锁

分布式锁

 public Map<String, List<Catelog2Vo>> getCatalogJsonFromdbWithredisLock() {

            //占分布式锁，去redis占坑 todo setnx建立锁空间
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock){
        //    加锁成功..执行业务
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            redisTemplate.delete("lock");//删除锁
            return  dataFromDb;
        }else {
        //    加锁失败...重试(自旋)
        //    休眠100s重试
        return getCatalogJsonFromdbWithLoaclLock();
        }

    }

    private Map<String, List<Catelog2Vo>> getDataFromDb() {
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
        if (!StringUtils.isEmpty(catalogJSON)) {
            /*缓存不为空，直接返回*/
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
            });
            return result;
        }
        List<CategoryEntity> level1Categorys = getLevel1Categorys();

        /*数据封装*/
        Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k ->
                k.getCatId().toString(), v -> {
            /*拿到每一个的一级分类，查询所有一级分类的二级分类*/
            List<CategoryEntity> categoryEntitys = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
            List<Catelog2Vo> catelog2Vos = null;
            if (categoryEntitys != null) {
                catelog2Vos = categoryEntitys.stream().map(l2 -> {
                    Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                    /*找当前二级分类的三级分类分装成ｖｏ*/
                    List<CategoryEntity> level3Catalog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", l2.getCatId()));
                    if (level3Catalog != null) {
                        List<Catelog2Vo.Category3Vo> collect = level3Catalog.stream().map(l3 -> {
                            Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                            return category3Vo;
                        }).collect(Collectors.toList());
                        catelog2Vo.setCatalog3List(collect);
                    }
                    return catelog2Vo;

                }).collect(Collectors.toList());
            }
            return catelog2Vos;
        }));
        //查询到的数据再放入缓存
        String s = JSON.toJSONString(parent_cid);
        redisTemplate.opsForValue().set("catalogJSON", s);
        return parent_cid;
    }

   /*使用redis构造分布式锁*/
    public Map<String, List<Catelog2Vo>> getCatalogJsonFromdbWithredisLock() {

            //占分布式锁，去redis占坑 todo setnx建立锁空间
        String uuid = UUID.randomUUID().toString();
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
        // Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock){
        //    加锁成功..执行业务
        //    设置过期时间,必须和加锁同步,原子命令进行占锁
        //     redisTemplate.expire("lock",30, TimeUnit.SECONDS);
            Map<String, List<Catelog2Vo>> dataFromDb;
            try {
                dataFromDb = getDataFromDb();
            } finally {
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then redis.call('del', KEYS[1]) return true else return false end";
                //保证原子性
                Integer lock1 = redisTemplate.execute(new DefaultRedisScript<Integer>(script,Integer.class),Arrays.asList("lock"),uuid);
            }
            // redisTemplate.delete("lock");//删除锁
            // String lockValue = redisTemplate.opsForValue().get("lock");
            // if (uuid.equals(lockValue)){
            //     /*删除自己的锁*/
            //     redisTemplate.delete("lock");
            // }
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then redis.call('del', KEYS[1]) return true else return false end";
            //保证原子性
            Integer lock1 = redisTemplate.execute(new DefaultRedisScript<Integer>(script,Integer.class),Arrays.asList("lock"),uuid);
            return  dataFromDb;
        }else {
        //    加锁失败...重试(自旋)
        //    休眠100s重试
        return getCatalogJsonFromdbWithLoaclLock();
        }

    }

    private Map<String, List<Catelog2Vo>> getDataFromDb() {
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
        if (!StringUtils.isEmpty(catalogJSON)) {
            /*缓存不为空，直接返回*/
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
            });
            return result;
        }
        List<CategoryEntity> level1Categorys = getLevel1Categorys();

        /*数据封装*/
        Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k ->
                k.getCatId().toString(), v -> {
            /*拿到每一个的一级分类，查询所有一级分类的二级分类*/
            List<CategoryEntity> categoryEntitys = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
            List<Catelog2Vo> catelog2Vos = null;
            if (categoryEntitys != null) {
                catelog2Vos = categoryEntitys.stream().map(l2 -> {
                    Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                    /*找当前二级分类的三级分类分装成ｖｏ*/
                    List<CategoryEntity> level3Catalog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", l2.getCatId()));
                    if (level3Catalog != null) {
                        List<Catelog2Vo.Category3Vo> collect = level3Catalog.stream().map(l3 -> {
                            Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                            return category3Vo;
                        }).collect(Collectors.toList());
                        catelog2Vo.setCatalog3List(collect);
                    }
                    return catelog2Vo;

                }).collect(Collectors.toList());
            }
            return catelog2Vos;
        }));
        //查询到的数据再放入缓存
        String s = JSON.toJSONString(parent_cid);
        redisTemplate.opsForValue().set("catalogJSON", s);
        return parent_cid;
    }

Redisson操作redis的客户端，主要是操作锁相关

整合redis作为分布式锁

引入锁依赖

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.12.0</version>
        </dependency>

配置redis

@Configuration
public class MyRedissonConfig {

    @Bean(destroyMethod = "shutdown")
    RedissonClient redissonClient(){
        Config config = new Config();
 /*       集群模式
        config.useClusterServers()
                .addNodeAddress("");*/
        //单节点模式
        //根据Config创建出RedissonClient示例
        config.useSingleServer().setAddress("redis://192.168.184.32:6379");
        return Redisson.create(config);
    }
}

分布式锁和同步器

基于Redis的Redisson分布式可重入锁Rlock，Java对象实现了java.util.concurrent.locks.lock接口

，同时还提供了异步(Async),反射式(Reactive)和Rxjava2标准接口。

• 解决锁的自动续期，如果业务超长，运行期间自动会给锁续上新的30s，不用担心业务时间长

锁自动过期删除

• 加锁的业务只是运行完成，就不会给当前锁续期，九四hi不手动解锁，锁默认在30s后解除

    //1.获取一把锁，只要锁的名字一样，就是同一把锁
        RLock lock = redissonClient.getLock("my-lock");
        //加锁
        lock.lock();//阻塞式等待
        try {
            System.out.println("加锁成功，执行业务。。。"+Thread.currentThread().getId());
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            System.out.println("释放锁"+Thread.currentThread().getId());
            lock.unlock();
        }

看门狗机制，自动续锁

读写锁(ReadWriteLock)

基于Redis的Redisson分布式可重入读写锁RReadWriteLock JAVA对象实现拿了JUC.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口

分布式可重入锁读写锁允许同时有对公锁和一个写锁处于加锁的状态

读写锁是成对出现的，写锁控制了读锁，写锁不存在，读锁加不加锁是一样的

  @ResponseBody
    @GetMapping("/write")
    public String wirteValue(){
        String s = null;
        //1.改数据加写锁，读数据用读锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.writeLock();
        try {
            rLock.lock();;
            s = UUID.randomUUID().toString();
            Thread.sleep(30000);
            redisTemplatebendi.opsForValue().set("writeValue",s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
        }
        return s;
    }
    @ResponseBody
    @GetMapping("/read")
    public String readValue(){
        String s = null;
        //加读锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.readLock();
        rLock.lock();
        try {
            s = redisTemplatebendi.opsForValue().get("writeValue");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
        }
        return s;
    }

读写锁，一定能读到最新数据，修改期间，写锁是一个排他锁（互斥锁），读锁是一个共享锁，写锁没释放读锁必须等待

• 写＋读：等待写锁释放
• 写＋写：阻塞方式
• 读＋写：等待读锁释放，有读锁，写也需要等待
• 读＋读：相当于无锁，并发读，只会在redis中记录好j，所有当前的读锁，他们都会同时加锁成功
• 只要有写的存在，都必须等待

闭锁（CountDownLatch）

基于Redisson的Redisson分布式锁Java对象RCountDownLatch采用了JUC.CountDownLATCH相似的接口和用法

信号量也可以作为分布式限流