業務場景：在電商專案中，往往會有這樣的一個功能設計，當用戶下單後一段時間沒有付款，系統就會在超時後關閉該訂單。

通常我們會做一個定時任務每分鐘來檢查前半小時的訂單，將沒有付款的訂單列表查詢出來，然後對訂單中的商品進行庫存的恢復，然後將該訂單設定為無效。

比如我們這裡使用Spring Schedule的方式做一個定時任務：

注：開啟Spring Schedule 的自動註解掃描,在Spring配置中新增<task:annotation-driven/>

@Component
@Slf4j
public class CloseOrderTask {

    @Autowired
 

    private IOrderService iOrderService;

    @Scheduled(cron = "0 */1 * * * ? ")
    public void closeOrderTaskV1() {
        log.info("定時任務啟動");
        //執行關閉訂單的操作
        iOrderService.closeOrder();
        log.info("定時任務結束");
    }
}

在單伺服器下這樣執行並沒有問題，但是隨著業務量的增多，勢必會演進成叢集模式，在同一時刻有多個服務執行一個定時任務就會帶來問題，首先是伺服器資源的浪費，同時會帶來業務邏輯的混亂，如果定時任務是做的資料庫操作將會帶來很大的風險。

Redis分散式鎖

下面分析一下分散式情況下定時任務的解決方案

通常使用Redis作為分散式鎖來解決這類問題，Redis分散式鎖流程如下：

Redis分散式鎖v1版本：

//注意：以下為了測試方便，定時時間都設定為10s
@Scheduled(cron = "0/10 * * * * ? ")
    public void closeOrderTaskV1() {
        log.info("定時任務啟動");
        long lockTime = 5000;//5秒
        Long lockKeyResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTime));

        //如果獲得了分散式鎖，執行關單業務
 

        if (lockKeyResult != null && lockKeyResult.intValue() == 1) {
            closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }else {
            log.info("沒有獲得分散式鎖");
        }
        log.info("定時任務結束================================");
    }

//關閉訂單，並釋放鎖
    private void closeOrder(String lockName) {
        RedisShardedPoolUtil.expire(lockName,50); //鎖住50秒
        log.info("執行緒{} 獲取鎖 {}",Thread.currentThread().getName(),lockName);

        //模擬執行關單操作
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //主動關閉鎖
        RedisShardedPoolUtil.del(lockName);
        log.info("執行緒{} 釋放鎖 {}",Thread.currentThread().getName(),lockName);
    }

(由於我電腦配置比較低，開2個IDEA程序除錯會比較卡，所以一個專案在IDEA除錯，另外一個打成war放在tomcat執行，打包命令

mvn clean package -Dmaven.test.skip=true -Pdev

)

tomcat1除錯日誌

tomcat2日誌

此時分散式鎖已經生效，在叢集環境下不會同時出現2個任務同時執行的情況，但是這時又引出了另外一個問題，

我們的邏輯是先setnx獲取分散式鎖（此時該鎖沒有設定過期時間，即不會過期）,然後expire設定過期鎖過期時間，如果在獲取鎖和設定過期時間之間，伺服器（tomcat）掛了就會出現鎖永遠都不會過期的情況！

• 在正常關閉tomcat的情況下（shutdown），我們可以通過@PreDestory執行刪除鎖邏輯，如下

@PreDestroy
    public void delCloseLock(){
        RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        log.info("Tomcat shut down 釋放鎖 {}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    }

• 在tomcat被kill或意外終止時，以上方法並不管用

  Redis分散式鎖v2版本 :

  

  我們將setnx未獲取到鎖的情況進行重新設計，為的是防止v1版本死鎖的產生，當第一次未獲取到鎖時，取出lockKey中存放的過期時間，與當前時間進行對比，若已超時則通過getset操作重置獲取鎖並更新過期時間，若第一次取出時未達到過期時間，說明還在上次任務執行的有效時間範圍內，可能就需要等這一段時間，通常過期時間設定為2~5秒，不會太長。

以上則是在超時的基礎上防止死鎖的產生，以下為程式碼實現：

//注意：以下為了測試方便，定時時間都設定為10s
@Scheduled(cron = "0/10 * * * * ? ")
    public void closeOrderTaskV2() {
        log.info("定時任務啟動");
        long lockTime = 5000; //5s
        Long lockKeyResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTime));

        //如果獲得了分散式鎖，執行關單業務
        if (lockKeyResult != null && lockKeyResult.intValue() == 1) {
            closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }else {
            String lockValue1 = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            //查到鎖的值並與當前時間比較檢查其是否已經超時，若超時則可以重新獲取鎖
            if (lockValue1 != null && System.currentTimeMillis() > Long.valueOf(lockValue1)) {

                //通過用當前時間戳getset操作會給對應的key設定新的值並返回舊值，這是一個原子操作
                //redis返回nil,則說明該值已經無效
                String lockValue2 = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTime));

                if (lockValue2 == null || StringUtils.equals(lockValue1, lockValue2)) {
                    //獲取鎖成功
                    closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                } else {
                    log.info("沒有獲得分散式鎖:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                }
            }

            log.info("沒有獲得分散式鎖:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }
        log.info("定時任務結束================================");
    }

至此，我們的這個分散式鎖是沒有問題了。

下面介紹一下使用Redisson這個框架來實現分散式鎖。

Redisson實現分散式鎖

Redisson是架設在Redis基礎上的一個Java駐記憶體資料網格（In-Memory Data Grid） ,其功能十分強大，解決很多分散式架構中的問題，附上其GitHub的WIKI地址：https://github.com/redisson/redisson/wiki

要引入Redisson，首先加入其pom依賴與spring整合：

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

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

在我們的工具類中建立RedissonManager完成Redisson的初始化：

@Component
@Slf4j
public class RedissonManager {

    private Redisson redisson = null;
    private Config config = new Config();

    private static String host1 = PropertiesUtil.getProperty("redis1.host");
    private static int port1 = Integer.parseInt(PropertiesUtil.getProperty("redis1.port"));
    private static String host2 = PropertiesUtil.getProperty("redis2.host");
    private static int port2 = Integer.parseInt(PropertiesUtil.getProperty("redis2.port"));

    @PostConstruct
    private void init() {
        try {
            config.useSingleServer().setAddress(new StringBuilder().append(host1).append(":").append("port1").toString());

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

    public Redisson getRedisson() {
        return redisson;
    }
}

初始化完成之後就可以來寫分散式鎖了，使用完Redisson實現分佈鎖之後就會發現一切是那麼的簡便：

//使用Redisson實現分散式鎖
@Scheduled(cron = "0/10 * * * * ? ")
    public void closeOrderTaskV3() {
        log.info("定時任務啟動");
        RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        boolean getLock = false;
        try {
            //todo 若任務執行時間過短，則有可能在等鎖的過程中2個服務任務都會獲取到鎖，這與實際需要的功能不一致，故需要將waitTime設定為0
            if (getLock = lock.tryLock(0, 5, TimeUnit.SECONDS)) {
                int hour = Integer.parseInt(PropertiesUtil.getProperty("close.redis.lock.time","2"));
                iOrderService.closeOrder(hour);
            } else {
                log.info("Redisson分散式鎖沒有獲取到鎖:{},ThreadName :{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
           log.error("Redisson 獲取分散式鎖異常",e);
        }finally {
            if (!getLock) {
                return;
            }
            lock.unlock();
            log.info("Redisson分散式鎖釋放鎖:{},ThreadName :{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
        }
    }

以上就是Redisson的分散式鎖實現程式碼，下面來分析一下：

1.RLock lock = redissonManager.getRedisson().getLock(String lockName);

RLock繼承自java.util.concurrent.locks.Lock，可以將其理解為一個重入鎖，需要手動加鎖和釋放鎖

來看它其中的一個方法：tryLock(long waitTime, long leaseTime, TimeUnit unit)

2.getLock = lock.tryLock(0, 5, TimeUnit.SECONDS)

通過tryLock()的引數可以看出，在獲取該鎖時如果被其他執行緒先拿到鎖就會進入等待，等待waitTime時間，如果還沒用機會獲取到鎖就放棄，返回false；若獲得了鎖，除非是呼叫unlock釋放，那麼會一直持有鎖，直到超過leaseTime指定的時間。

以上就是Redisson實現分散式鎖的核心方法，有人可能要問，那怎麼確定拿的是同一把鎖，分散式鎖在哪？

這就是Redisson的強大之處，其底層還是使用的Redis來作分散式鎖，在我們的RedissonManager中已經指定了Redis例項，Redisson會進行託管，其原理與我們手動實現Redis分散式鎖類似。

Kay 2018.5.23