在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("=============================");
    }

#2018-04-10 21:57:01 再来填坑

再解释一下上面的逻辑，注意：上面有两个时间，一个key的过期时间，一个锁的过期时间。都是为了避免死锁的发生。

为毛要设置两个呢？任意一个都可以避免死锁啊？因为当我们setnx的时候是不能设置过期时间的，如果刚好setnx之后突然断电还没来得及设置key的过期时间，那岂不是会发生死锁。所以我们要再来个锁的过期时间来进一步判断。最根本原因是得到锁和设置key的过期时间没有同步，下面介绍一个redis分布式锁的框架。轻松解决分布式锁的问题，原理和上面一样，不过代码更为简单。不用过多的判断，框架已经帮我们做好了。

注意：Redisson这个框架不支持分布式就是只能一个redis，但是支持主从模式。和spring的session框架一样。切记

pom.xml     这个是Redisson所需的依赖

<dependency>
      <groupId>org.redisson</groupId>
      <artifactId>redisson</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!--com.fasterxml.jackson.dataformat.avro.PackageVersion-->
    <dependency>
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-avro</artifactId>
      <version>2.9.0</version>
    </dependency>

RedissonManager.java

package com.mmall.common;

import com.mmall.util.PropertiesUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * Created by geely
 */
@Slf4j
@Component
public class RedissonManager {
    //在redis环境没有搭建起来之前，这里先注释上，否则项目启动不起来。

    private Config config = new Config();

    private Redisson redisson = null;

    private final static String redis1Ip = PropertiesUtil.getProperty("redis1.ip");
    private final static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port"));

    //注入到Spring容器的话，使用@PostConstruct或者静态块初始化，效果是一样的{}

    @PostConstruct
    private void init() {
        try {
            //在redis环境没有搭建起来之前，这里先注释上，否则项目启动不起来。

            ////127.0.0.1:6379
             config.useSingleServer().setAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString());

            //单主模式
//            config.useMasterSlaveServers().setMasterAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString());

            //主从模式
//            config.useMasterSlaveServers().setMasterAddress("10.211.55.6:6379").addSlaveAddress("10.211.55.6:6380");

//            redisson = (Redisson) Redisson.create(config);
            log.info("初始化Redisson结束");
        } catch (Exception e) {
            log.error("redisson init error", e);
        }
    }

//    {
//        init();
//    }

    public Redisson getRedisson() {
        return redisson;
    }

}

下面是具体实现代码，原理一样，只不过简化操作。切记：一定要把tryLock的第一个参数等待获取锁的时间设置为0.有坑

/**
     * Redisson分布式锁实现
     * @throws InterruptedException
     */
//    @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV4() throws InterruptedException {
        //意思是把Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK这个常量当成key
        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试着获取锁，2的意思是等待获取锁的时间为2s，要设为0，不然会出现一些意想不到的错误，50的意思就是锁的过期时间(同样也是key的过期时间)
                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();
        }
    }

ok，原生的方法有了，框架的也有了。点个赞吧。