Redis_08_Redis实现分布式锁

1.为什么需要分布式锁。

当我们的应用程序，有多个实例，部署在多个服务器上时。当我们进行对操作库存，秒杀等操作时，一定需要加锁保证我们的库存数量被正确的赋值，但是我们的Lock锁，Synchronized锁都是基于我们的JVM的，但是我们的项目时多实例，部署在多个应用服务器的，这时候我们的本地锁就不能保证我们操作的原子性了。这时候我们需要一个服务器级别的锁，也就是分布式锁。

2.分布式锁的实现基于Redis

分布式锁，其实原理是就是多台机器，去争抢一个资源，谁争抢成功，那么谁就持有了这把锁，然后去执行后续的业务逻辑，执行完毕后，把锁释放掉。通过redis的setnx方式（不存在则设置）,往redis上设置一个带有过期时间的key，如果设置成功，则获得了分布式锁。

3.代码实现和会出现的问题我们一点点的看

我们就以对库存的加减为案例：

基础代码：

解析：单服务应用下好像没什么问题，第一个请求进来会执行库存扣除操作，第二个请求会等待等一个请求释放锁，拿到锁对象后进行操作。

问题：多个实例服务器时，Synchronied()锁就没有用了。

　　 @Autowired
    private RedisTemplate redisTemplate;

    private static final String STOCK = "stock";

    /**
     * @Description:redis 分布式锁模拟高并发下库存删减
     * @Author: hdh
     * @Date: 2021/2/1
     * @return: java.lang.String
     **/
    @RequestMapping("stock")
    private synchronized String stock() {
        //从redis中获取库存
        int stock = (Integer) redisTemplate.opsForValue().get(STOCK);
        if (stock > 0) {
            redisTemplate.opsForValue().set(STOCK, stock - 1);
            return "扣除库存成功";
        }
        return "扣除库存失败，库存不足";
    }

解析：redis是单线程操作，能保证操作的原子性

redisTemplate.opsForValue().setIfAbsent（key,value）判断redis 中是否存在key存在不进行操作返回false，不存在保存key返回true；

问题：解决了锁的问题，出现了新的问题，如果在扣除库存抛出了异常redis锁没有及时释放，那么该请求会被死锁

@RequestMapping(“stock”)
private String stock() {

     Boolean redis_lock = redisTemplate.opsForValue().setIfAbsent("REDIS_LOCK", REDIS_LOCK);
     if (!redis_lock) {
         return "业务繁忙，请稍后再试";
     }

     //从redis中获取库存
     int stock = (Integer) redisTemplate.opsForValue().get(STOCK);
     if (stock > 0) {
         redisTemplate.opsForValue().set(STOCK, stock - 1);
         redisTemplate.delete(REDIS_LOCK);
         return "扣除库存成功";
     }
     redisTemplate.delete(REDIS_LOCK);
     return "扣除库存失败，库存不足";
 }

解析：通过给锁setIfAbsent（）设置过期时间可以防止被锁一直被占用

将释放锁放在finally中，可以保证不会死锁。

REDIS_LOCK + uuid： 实现了自己设置的锁只有自己可以销毁

问题 ：setIfAbsent（）设置过期时间，如果在过期时间内业务代码没有执行完，那么下一个请求就会进来执行，而上一个请求执行完就会释放锁，导致锁直接失效了。但是时间又不能设置过长，如果在执行业务代码的时候宕机了，那么会导致多个服务的库存接口直接死锁。设置多少秒的锁合适呢。

@RequestMapping(“stock”)
private String stock() {

      String uuid = String.valueOf(UUID.randomUUID());
      //加上过期时长，该锁10s后自动被释放
      Boolean redis_lock = redisTemplate.opsForValue().setIfAbsent(REDIS_LOCK + uuid, REDIS_LOCK, 10, TimeUnit.SECONDS);
      if (!redis_lock) {
          return "业务繁忙，请稍后再试";
      }

      try {
          int stock = (Integer) redisTemplate.opsForValue().get(STOCK);
          if (stock > 0) {
              redisTemplate.opsForValue().set(STOCK, stock - 1);
              redisTemplate.delete(REDIS_LOCK+uuid);
              return "扣除库存成功";
          }
      } finally {
          //发生异常自动解锁
          redisTemplate.delete(REDIS_LOCK+uuid);
      }
      //从redis中获取库存
      return "扣除库存失败，库存不足";
  }

4. redisson redis客户断的实现

        <!--redisson redis客户端-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.6.5</version>
        </dependency>

bean初始化
@Bean
public Redisson redisson() {
//单机模式
Config config = new Config();
config.useSingleServer().setAddress(“redis://127.0.0.1:6379”).setPassword(“12345”).setDatabase(0);

    //添加多个实例
    /*config.useClusterServers()
            .addNodeAddress("redis://127.0.0.1:6379")
            .addNodeAddress("redis://127.0.0.1:6379")
            .addNodeAddress("redis://127.0.0.1:6379");*/
    return (Redisson) Redisson.create(config);
}

5. redisson实现分布式锁

@RequestMapping("stock")
    private String stock() {
        RLock lock = redisson.getLock(LOCK_KEY);
        try {
            //设置锁
            lock.lock();
            int stock = (Integer) redisTemplate.opsForValue().get(STOCK);
            if (stock > 0) {
                redisTemplate.opsForValue().set(STOCK, stock - 1);
                return "扣除库存成功";
            }
        } finally {
            //解除锁
            lock.unlock();
        }
        return "扣除库存失败，库存不足";
    }

redisson底层其实是做了setIfAbsent(REDIS_LOCK + uuid, REDIS_LOCK, 10, TimeUnit.SECONDS);

但是redisson会使用后台线程检查是否继续持有锁，如果继续持有则延长锁的时间

6. 实例化不同的redis实例连接多个redisson客户端连接

@RequestMapping("stock")
    private String stock() {
        RLock lock1 = redisson1.getLock(LOCK_KEY);
        RLock lock2 = redisson2.getLock(LOCK_KEY);
        RLock lock3 = redisson3.getLock(LOCK_KEY);
         //根据多个RLock对象创建RedissonRedLock;
        RedissonRedLock redLock=newRedissonRedLock(lock1,lock2,lock3);
        try {
            //设置锁
            boolen res=redLock.try.Lock(10,30,TimeUnit.SECONDS);
            //判断锁是否设置成功
            if(res){
              int stock = (Integer)redisTemplate.opsForValue().get(STOCK);
                if (stock > 0) {
                  redisTemplate.opsForValue().set(STOCK, stock - 1);
                  return "扣除库存成功";
                }
            }    
        } finally {
            //解除锁
            lock.unlock();
        }
        return "扣除库存失败，库存不足";
    }