在tomcat集群环境下redis实现分布式锁

上篇介绍了redis在集群环境下如何解决session共享的问题。今天来讲一下如何解决分布式锁的问题

什么是分布式锁？

分布式锁就是在多个服务器中，都来争夺某一资源。这时候我们肯定需要一把锁是不是，这个锁就是分布式锁，就算不是分布式，单机情况下，多个进程来争夺同一个资源，我们也要一把锁来控制先后顺序不是。分布式锁就是在多个服务器场景中来争夺相同的资源。打个比方，比如调度任务。

比如说，我们一个商城网站，要求每分钟要执行一个定时任务的操作，目的是把下单之后30分钟未付款的，把订单取消，然后把库存还原过去。因为是在多tomcat下，这个定时任务肯定会在同一时刻多个服务器都要执行操作。但是我们需要的是其中一个服务器操作就行了。这时候，就要用到我们的分布式锁啦。

我们在用redis来实现这个分布式锁的功能。我们会用到setnx方法，del方法，expire方法，getset方法（这些方法的特性自己去百度下最好）

大致原理：我们利用setnx方法来设置一个key（写死的，以后都要用这个key获取锁），value的值（当前时间戳+锁的过期时间），如果设置成功返回1，说明我们已经获取锁，

然后再用expire方法设置key的有效期，因为肯定要有一个有效期的，不然你这一分钟已经执行完了，别人还想利用setnx获取锁，就一直获取不到，就造成了死锁。

设置好有效期之后，然后执行关单的业务逻辑，然后删除key。

其他服务器同时间操作，也是先setnx一下，结果发现别人已经获取到了锁，就返回失败0，然后就不执行关单操作。

上面的方法看似还可以，但是有一些bug，比如说服务器1setnx之后准备设置过期时间勒，服务器重启了，那是不是这个key就一直就消失不了了，那就造成了死锁。后面的永远都获取不到这个锁。细心的你肯定发现了，我们之前setnx的时候value还没用上呢？哈哈，现在就要用上了，我们来稍微改造一下。

我们之前的逻辑是如果获取锁，就执行设置过期时间，关单操作，没有获取锁就不执行关单操作。

我们现在改成如果没有获取锁，再进行一次判断，我们获取当前这个锁的value，因为key是我们写死的常量，我们可以从redis获取value时间戳

我们得到时间戳之后判断一下，这个时间戳和当前时间比那个大，如果当前时间大，说明这个锁已经过期了。因为我们上面已经说了，这个value的值就是当前时间+锁的过期时间

然后我们用getset方法重新设置锁的有效期，然后得到老得时间和再用单纯的get方法再获取老得时间，看是否相等，这点非常重要，因为相等说明中间没有其他线程获取到这个锁。可能有点迷，看代码就不迷了。ok 看代码吧

第一种会出现死锁的场景和第二种双重判断防止死锁的场景都有注释很清楚

/**
     * 可能出现死锁，虽然在执行close的时候有防死锁，但是还是会出现，继续演进V3
     */
//    @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV2() throws InterruptedException {
        long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));//锁5秒有效期
        //这个时间如何用呢，看下面。和时间戳结合起来用。
        Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
        if(setnxResult != null && setnxResult.intValue() == 1){
            //如果返回值是1，代表设置成功，获取锁
            closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }else{
            log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }
    }


    /**
     * 防死锁之分布式锁
     * @throws InterruptedException
     */
//    @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV3() throws InterruptedException {
        //防死锁分布式锁
        long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","50000"));//锁50秒有效期
        //项目由于历史数据关单订单比较多,需要处理,初次用50s时间,后续改成5s即可.同时50s也为了讲课debug的时候时间长而设置。
        //大家可以根据实际情况，如果历史订单都处理完毕，或者在外部进行洗数据ok，这里的lock的时间应该设置小一些，例如1s 2s 3s 4s 5s就足够啦。



        //这个时间如何用呢，看下面。和时间戳结合起来用。
        Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
        if(setnxResult != null && setnxResult.intValue() == 1){
            //如果返回值是1，代表设置成功，获取锁
            closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }else{
            //如果setnxResult==null 或 setnxResult.intValue() ==0 即 != 1的时候
            //未获取到锁，继续判断,判断时间戳,看是否可以重置获取到锁
            String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);

            //如果lockValue不是空,并且当前时间大于锁的有效期,说明之前的lock的时间已超时,执行getset命令.
            if(lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){
                String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
                //再次用当前时间戳getset，
                //返回给定 key 的旧值。  ->旧值判断，是否可以获取锁
                // 当 key 没有旧值时，即 key 不存在时，返回 nil 。 ->获取锁
                //这里我们set了一个新的value值，获取旧的值。
                if(getSetResult == null || (getSetResult !=null && StringUtils.equals(lockValueStr,getSetResult))){
                    //获取到锁
                    closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                }else{
                    log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                }
            }else{
                log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }
        }
    }


    /**
     * Redisson分布式锁实现
     * @throws InterruptedException
     */
//    @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV4() throws InterruptedException {
        RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        boolean getLock = false;
        try {
            if(getLock = lock.tryLock(2,50, TimeUnit.SECONDS)){//trylock增加锁
                log.info("===获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
                int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
                iOrderService.closeOrder(hour);
            }else{
                log.info("===没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }
        }finally {
            if(!getLock){
                return;
            }
            log.info("===释放分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            lock.unlock();
        }
    }



    private void closeOrder(String lockName){
//        expire命令用于给该锁设定一个过期时间，用于防止线程crash，导致锁一直有效，从而导致死锁。
        RedisShardedPoolUtil.expire(lockName,50);//有效期50秒,防死锁
        log.info("获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
        int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
        iOrderService.closeOrder(hour);
        RedisShardedPoolUtil.del(lockName);//释放锁
        log.info("释放{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
        log.info("=============================");
    }

View Code