缓存篇-使用Redis进行分布式锁应用

---

前言

本地缓存的问题：每个微服务都得要有自己的缓存服务，数据更新时只能更新本服务的缓存 造成数据不一致。分布式项目时，本地锁只能锁住当前服务。

---

一、redis分布式锁的原理

redis命令中setnx表示同一时刻只能设置成功一个。

• nx 表示notexist

二、使用redis进行分布式锁改造

抽取访问数据库的代码

private Map<String, List<Catelog2Vo>> getDataFromDB() {
   //线程进入之前，再次查缓存
   String catelogJson = stringRedisTemplate.opsForValue().get("catelogJson");
   if (StringUtils.isNotEmpty(catelogJson)) {
       //如果缓存中有数据
       //解析成json返回
       return JSON.parseObject(catelogJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {
       });
   }
   //如果缓存中没有，就查库

   //查全部
   List<CategoryEntity> categoryEntities = baseMapper.selectList(null);
   //查询所有一级目录
   List<CategoryEntity> categoryLevel01 = getCategoryEntities(categoryEntities, 0L);
   Map<String, List<Catelog2Vo>> parent_cid = categoryLevel01.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
       //遍历 拿到每个一级分类的二级分类
       List<CategoryEntity> categoryLevel02 = getCategoryEntities(categoryEntities, v.getCatId());
       List<Catelog2Vo> catelog2Vos = null;
       if (categoryLevel02 != null) {
           catelog2Vos = (List<Catelog2Vo>) categoryLevel02.stream().map(l2 -> {
               Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), l2.getName(), l2.getCatId().toString(), null);
               //三级分类
               List<CategoryEntity> categoryLevel03 = getCategoryEntities(categoryEntities, l2.getCatId());
               if (categoryLevel03 != null) {
                   List<Catelog3Vo> catelog3Vo = categoryLevel03.stream().map(l3 -> new Catelog3Vo(l3.getCatId().toString(), l3.getName(), l2.getCatId().toString())).collect(Collectors.toList());
                   catelog2Vo.setCatelog3VoList(catelog3Vo);
               }
               return catelog2Vo;
           }).collect(Collectors.toList());
       }
       return catelog2Vos;
   }));

   //在返回数据之前，将数据放入缓存，保证原子性
   //将数据转换成json串保存在redis中
   stringRedisTemplate.opsForValue().set("catelogJson", JSON.toJSONString(parent_cid));
   return parent_cid;
}

1.第一阶段

1.使用setnx进行加锁

在redisTemplate中使用setIfAbsent进行setnx操作。

 //进行分布式锁的改造
public Map<String, List<Catelog2Vo>> getCatelogJsonFromWithDistributeLock() {
      //设置分布式锁
  Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
  if(lock){
      //加锁成功.执行业务
      Map<String, List<Catelog2Vo>> dataFromDB = getDataFromDB();
      //业务执行成功，需要解锁
      stringRedisTemplate.delete("lock");
      return dataFromDB;
  }else {
      //加锁失败
      //进行重试，自旋
      //休眠
      return  getCatelogJsonFromWithDistributeLock();
  }
}

2.出现的问题（死锁）

2.第二阶段（解决第一阶段死锁问题）

1.设置过期时间

public Map<String, List<Catelog2Vo>> getCatelogJsonFromWithDistributeLock() {
        //设置分布式锁
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
    if(lock){
        //加锁成功.执行业务
        //设置过期时间
        stringRedisTemplate.expire("lock",30, TimeUnit.SECONDS);
        Map<String, List<Catelog2Vo>> dataFromDB = getDataFromDB();
        //业务执行成功，需要解锁
        stringRedisTemplate.delete("lock");
        return dataFromDB;
    }else {
        //加锁失败
        //进行重试，自旋
        //休眠
        return  getCatelogJsonFromWithDistributeLock();
    }
}

2.出现问题（设置key和过期时间不是原子性）

3.解决key和过期时间不是原子性

使用setnx ex

Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111",300,TimeUnit.SECONDS);

3.第三阶段（出现删锁问题）

当设置过期时间小于业务执行代码时间时，业务代码未执行完，锁被释放，其他线程应用此时再次抢到lock锁，之前线程执行代码完成后，需要删除锁，此时删除的就不再是自己的锁了，是其他线程的锁。导致问题出现。

1.解决删掉其他线程锁的问题（指定值为uuid）

//进行分布式锁的改造
public Map<String, List<Catelog2Vo>> getCatelogJsonFromWithDistributeLock() {
    //指定值为uuid，确保删除的是当前锁
    String redisValue = UUID.randomUUID().toString();
    //设置分布式锁
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", redisValue,300,TimeUnit.SECONDS);
    if(lock){
        //加锁成功.执行业务
        Map<String, List<Catelog2Vo>> dataFromDB = getDataFromDB();
        //业务执行成功，需要解锁
        //判断是否是当前锁
        if(redisValue.equals(stringRedisTemplate.opsForValue().get("lock"))){
            //如果匹配，就执行删除
            stringRedisTemplate.delete("lock");
        }
        return dataFromDB;
    }else {
        //加锁失败
        //进行重试，自旋
        //休眠
        return  getCatelogJsonFromWithDistributeLock();
    }
}

2.出现问题（依然不是原子性删除）

如果判断为true之后，redis中lock时间到期，此时删除的依然不是自己的key

4.第四阶段（原子操作解决删锁问题）

使用redis+lua脚本保证原子性

if redis.call("get",KEYS[1]) == ARGV[1]
then
    return redis.call("del",KEYS[1])
else
    return 0
end

String luaScript="if redis.call(\"get\",KEYS[1]) == ARGV[1] then return redis.call(\"del\",KEYS[1]) else return 0 end";

//进行分布式锁的改造
public Map<String, List<Catelog2Vo>> getCatelogJsonFromWithDistributeLock() {
    //指定值为uuid，确保删除的是当前锁
    String redisValue = UUID.randomUUID().toString();
    //设置分布式锁
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", redisValue,300,TimeUnit.SECONDS);
    if(lock){
        //加锁成功.执行业务
        Map<String, List<Catelog2Vo>> dataFromDB = getDataFromDB();
        //业务执行成功，需要解锁
        //判断是否是当前锁


        String luaScript="if redis.call(\"get\",KEYS[1]) == ARGV[1] then return redis.call(\"del\",KEYS[1]) else return 0 end";
//            if(redisValue.equals(stringRedisTemplate.opsForValue().get("lock"))){
//                //如果匹配，就执行删除
//                stringRedisTemplate.delete("lock");
//            }

        Integer lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Integer>(luaScript, Integer.class),
                Arrays.asList("lock"), redisValue);
        return dataFromDB;
    }else {
        //加锁失败
        //进行重试，自旋
        //休眠
        return  getCatelogJsonFromWithDistributeLock();
    }
}

最后在finally执行删锁命令

//进行分布式锁的改造
public Map<String, List<Catelog2Vo>> getCatelogJsonFromWithDistributeLock() {
    //指定值为uuid，确保删除的是当前锁
    String redisValue = UUID.randomUUID().toString();
    //设置分布式锁
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", redisValue,300,TimeUnit.SECONDS);
    Map<String, List<Catelog2Vo>> dataFromDB = null;
    if(lock){
        try {
            dataFromDB = getDataFromDB();
        }catch (Exception e){
            String luaScript="if redis.call(\"get\",KEYS[1]) == ARGV[1] then return redis.call(\"del\",KEYS[1]) else return 0 end";
            Integer lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Integer>(luaScript, Integer.class),
                    Arrays.asList("lock"), redisValue);
        }

        return dataFromDB;
    }else {
        return  getCatelogJsonFromWithDistributeLock();
    }
}

总结

不论是加锁还是删锁，都得保证原子性。