今天工作之餘，檢視一下利用redis來實現分散式鎖，因此，在檢視別人文章之餘，自己也來手動模擬實現Java的lock介面，來自己手動實現一個分散式鎖。擁有簡單的加鎖，解鎖，鎖中斷等操作。

利用redis的分散式鎖，主要還是利用redis的setnx命令，檢視redis文件，可知次命令在redis快取中新增資料的時候，如果key存在，則新增資料操作不成功。若不存在，才可以新增成功。從另外一個方面來理解鎖（Lock），其實就是一種資源，在某個時刻標記為只能被某個執行緒使用，若資源已經被使用，則其他執行緒必須等待當前執行緒釋放資源之後才可以使用。從這個方面理解，也就是，當前執行緒持有在redis快取中key的資源，所以其他執行緒必須等待當前執行緒釋放key的資源，否則只能等待。下面來貼上程式碼具體分析下：

package com.redislock;

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 嘗試使用redis實現分散式鎖
 * Created by hadoop on 2017/3/16.
 */
public class RedisLock implements Lock{

    /**jedis客戶端**/
    private final Jedis jedis;
 

    /**鎖定資源的key**/
    private final String lockName;
    /**持有鎖的最長時間**/
    private final int expireTime = 300;
    /**獲取不到鎖的休眠時間**/
    private final long sleepTime = 100;
    /**鎖中斷狀態**/
    private boolean interruped = true;
    /**超時時間**/
    private long expireTimeOut = 0;

    public RedisLock(Jedis jedis, String lockName){
        this.jedis = jedis;
        this.lockName = lockName;
    }

    public void lock() {
        if (jedis == null)
            throw new NullPointerException("jedis is null");
        if (lockName == null)
            throw new NullPointerException("key is null");
        while (true){
            if (!interruped)
                throw new RuntimeException("獲取鎖狀態被中斷");
            long id = jedis.setnx(lockName, lockName);
            if (id == 0L){
                try {
                    Thread.currentThread().sleep(this.sleepTime);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }else{
                expireTimeOut = System.currentTimeMillis()/1000 + expireTime;
                jedis.expireAt(this.lockName, expireTimeOut);
                break;
            }
        }
    }

    public void lockInterruptibly() throws InterruptedException {
        this.interruped = false;
    }

    public boolean tryLock() {
        if (jedis == null)
            throw new NullPointerException("jedis is null");
        if (lockName == null)
            throw new NullPointerException("lockName is null");
        if (!interruped)
            throw  new RuntimeException("執行緒被中斷");
        long id = jedis.setnx(lockName, lockName);
        if (id == 0L)
            return false;
        else {
            // 設定鎖過期時間
            expireTimeOut = System.currentTimeMillis()/1000 + expireTime;
            jedis.expireAt(this.lockName, expireTimeOut);
            return true;
        }
    }

    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        if (jedis == null)
            throw new NullPointerException("jedis is null");
        if (lockName == null)
            throw new NullPointerException("lockName is null");
        if (time == 0)
            return false;
        long now = System.currentTimeMillis();
        long timeOutAt = now + calcSeconds(time, unit);
        while (true){
            if (!interruped)
                throw new InterruptedException("執行緒被中斷");
            long id = jedis.setnx(this.lockName, this.lockName);
            // id = 0 表示加鎖失敗
            if(id == 0){
                // 獲取鎖超時
                if(System.currentTimeMillis() > timeOutAt)
                    return false;
                try {
                    // 休眠一段時間，繼續獲取鎖
                    Thread.currentThread().sleep(this.sleepTime);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }else {
                //獲取鎖成功，設定鎖過期時間
                expireTimeOut = System.currentTimeMillis()/1000 + expireTime;
                jedis.expireAt(this.lockName, expireTimeOut);
                return true;
            }
        }
    }

    public void unlock() {
        try {
            //當前時間小於過期時間,則鎖未超時,刪除鎖定
            if (System.currentTimeMillis() / 1000 < expireTimeOut)
                jedis.del(lockName);
        }catch (Exception e){

        }finally {
            jedis.close();
        }
    }

    public Condition newCondition() {
        throw new UnsupportedOperationException("不支援當前的操作");
    }

    /**
     * 時間轉換成毫秒
     * @param time
     * @param unit
     * @return
     */
    private long calcSeconds (long time, TimeUnit unit){
        if (unit == TimeUnit.DAYS)
            return time * 24 * 60 * 60 * 1000;
        else if (unit == TimeUnit.HOURS)
            return time * 60 * 60 * 1000;
        else  if (unit == TimeUnit.MINUTES)
            return time * 60 * 1000;
        else
            return time * 1000;
    }
}
 

在這裡，第一，我是利用實現Lock介面的方式來實現這個鎖，在使用鎖的時候，一般為一個執行緒持有一把鎖，因此鎖可以看成是線上程自己的內部堆疊裡面，因此可以不用考慮多執行緒的支援。重點是在獲取鎖的介面，獲取鎖意味著對資源的競爭，因此在本示例中，我嘗試迴圈獲取物件的鎖，也就是迴圈向redis裡面新增資料，新增成功，則代表加鎖成功，新增不成功，則代表加鎖失敗，休眠一段時間之後，繼續獲取鎖。因此這個lock方法為阻塞的，獲取不到鎖，就會一直去獲取。newCondition方法沒有實現，也是基於目前才疏學淺，還不回使用，後面會考慮加上這個newCondition方法。

在這裡，說兩點，第一點就是redis key的超時，這樣可以保證在客戶端程式突然down的時候，資源可以在一段時間之後被釋放掉，不會產生死鎖。還有就是unlock()這個方法，在加鎖的時候，會計算鎖釋放的時間，在釋放鎖的時候，要判定當前鎖是否超時了，若超時，怎不能刪除key。否則會破壞執行緒的安全性。因為不用的redis客戶端，雖然不能setnx key值，但是可以del這個key。當然，我這裡是一種最簡單的處理，在臨界條件下也容易出現問題，只是目前可以想到的一種辦法。也希望大神們不吝賜教小弟我。

第二點需要說明的是中斷狀態，基於以前看多執行緒安全結束的模式，在此處我也是設定標誌量interruped 用來標識當前的鎖已經被中斷，在進行任何操作前，都會先判定這個中斷標誌，若被中斷，則丟擲程式異常。 目前還不知道這樣做到底會如何，希望路過大神給指導一下意見！！！完全自學，希望不吝賜教。在寫的過程中，考慮到一件事情，若中斷標誌被改變，也就是鎖被中斷，是否需要呼叫unlock（）方法釋放這個鎖？？？

留下諸多疑問，希望路過的朋友留下自己的意見！