redis 不可重入分佈式鎖(setNx()和getset()方法實現)

一般若是在單機環境，使用synchronized或juc ReentrantLock 實現鎖機制，但若是是分佈式系統，則須要藉助第三方工具實現，好比redis、zookeeper等。
redis爲單進程單線程模式，操做都是原子過程，採用隊列模式將併發訪問變成串行訪問，且多客戶端對redis的鏈接並不存在競爭關係。
---------------------

1、redis 基本命令
setnx 命令（『SET if Not eXists』(若是不存在，則 SET)的簡寫）：
設置成功，返回 1 。
設置失敗，返回 0 。
該命令是原子操做。

getset 命令：
自動將key對應到value而且返回原來key對應的value。若是key存在可是對應的value不是字符串，就返回錯誤。
* 返回值 *：
返回以前的舊值，若是以前Key不存在將返回null。
該命令是原子操做。

get 命令：
get <key> 獲取key的值，若是存在，則返回；若是不存在，則返回null；

del 命令：
del <key> 刪除key及key對應的值，若是key不存在，程序忽略

2、使用SETNX實現分佈式鎖
redis官網推薦的setnx實現分佈式鎖以下，多個進程執行如下Redis命令：
SETNX lock.foo {current Unix time + lock timeout + 1}

若是 SETNX 返回1，說明該進程得到鎖，SETNX將鍵 lock.foo 的值設置爲鎖的超時時間（當前時間 + 鎖的有效時間）。 
若是 SETNX 返回0，說明其餘進程已經得到了鎖，進程不能進入臨界區。進程能夠在一個循環中不斷地嘗試 SETNX 操做，以得到鎖。

3、死鎖問題
基於setnx、getset命令的分佈式鎖實現過程當中若是細節不反覆測試，很容易出現死鎖問題:
考慮一種狀況，若是進程得到鎖後，斷開了與 Redis 的鏈接（多是進程掛掉，或者網絡中斷），若是沒有有效的釋放鎖的機制，那麼其餘進程都會處於一直等待的狀態，即出現「死鎖」。上面在使用 SETNX 得到鎖時，咱們將鍵 lock.foo 的值設置爲鎖的有效時間，進程得到鎖後，其餘進程還會不斷的檢測鎖是否已超時，若是超時，那麼等待的進程也將有機會得到鎖。然而，鎖超時時，咱們不能簡單地使用 DEL 命令刪除鍵 lock.foo 以釋放鎖。考慮如下狀況，進程P1已經首先得到了鎖 lock.foo，而後進程P1掛掉了。進程P2，P3正在不斷地檢測鎖是否已釋放或者已超時，執行流程以下：
P2和P3進程讀取鍵 lock.foo 的值，檢測鎖是否已超時（經過比較當前時間和鍵 lock.foo 的值來判斷是否超時）
P2和P3進程發現鎖 lock.foo 已超時
P2執行 DEL lock.foo命令
P2執行 SETNX lock.foo命令，並返回1，即P2得到鎖
P3執行 DEL lock.foo命令將P2剛剛設置的鍵 lock.foo 刪除（這步是因爲P3剛纔已檢測到鎖已超時）
P3執行 SETNX lock.foo命令，並返回1，即P3得到鎖
P2和P3同時得到了鎖
從上面的狀況能夠得知，在檢測到鎖超時後，進程不能直接簡單地執行 DEL 刪除鍵的操做以得到鎖。爲了解決上述算法可能出現的多個進程同時得到鎖的問題，咱們再來看如下的算法。 
咱們一樣假設進程P1已經首先得到了鎖 lock.foo，而後進程P1掛掉了。接下來的狀況：
進程P4執行 SETNX lock.foo 以嘗試獲取鎖
因爲進程P1已得到了鎖，因此P4執行 SETNX lock.foo 返回0，即獲取鎖失敗
P4執行 GET lock.foo 來檢測鎖是否已超時，若是沒超時，則等待一段時間，再次檢測
若是P4檢測到鎖已超時，即當前的時間大於鍵 lock.foo 的值，P4會執行如下操做 
GETSET lock.foo {current Unix timestamp + lock timeout + 1}
因爲 GETSET 操做在設置鍵的值的同時，還會返回鍵的舊值，經過比較鍵 lock.foo 的舊值是否小於當前時間，能夠判斷進程是否已得到鎖。
假如另外一個進程P5也檢測到鎖已超時，並在P4以前執行了 GETSET 操做，那麼P4的 GETSET 操做返回的是一個大於當前時間的時間戳，這樣P4就不會得到鎖而繼續等待。注意到，即便P4接下來將鍵 lock.foo 的值設置了比P5設置的更大的值也沒影響。
另外，值得注意的是，在進程釋放鎖，即執行 DEL lock.foo 操做前，須要先判斷鎖是否已超時。若是鎖已超時，那麼鎖可能已由其餘進程得到，這時直接執行 DEL lock.foo 操做會致使把其餘進程已得到 的鎖釋放掉。

 

4、代碼實現
本文基於jedis2.9, 以java語言代碼實現，以下:

測試代碼入口：
private static final String lockKey = "lock:user_13";  
    public static void main(String[] args) {  
        Jedis jedis = new Jedis("127.0.0.1", 6379);  
          
        DistributedLockHandler distributedLockHandler = new DistributedLockHandler().setJedis(jedis);  
        try{  
            boolean getLock = distributedLockHandler.tryLock(lockKey, Long.valueOf(5));  
  
            if(getLock){  
                // Do your job  
                System.out.println("Do your job........");  
            }  
  
        }catch(Exception e){  
            System.out.println(e);  
        }finally {  
            distributedLockHandler.realseLock(lockKey);  
        }  
          
    }       

分佈式鎖實現代碼:
public class DistributedLockHandler {  
  
    private static final Integer Lock_Timeout = 3;  
    private Jedis jedis;  
  
    /** 
     * 外部調用加鎖的方法 
     * @param lockKey 鎖的key 
     * @param timeout 超時時間（放置時間長度，如：5L） 
     * @return 
     */  
    public boolean tryLock(String lockKey, Long timeout) {  
        try {  
            Long currentTime = System.currentTimeMillis();//開始加鎖的時間  
            boolean result = false;  
              
            while (true) {  
                if ((System.currentTimeMillis() - currentTime) / 1000 > timeout) {//當前時間超過了設定的超時時間  
                    System.out.println("Execute DistributedLockHandler.tryLock method, Time out.");  
                    break;  
                } else {  
                    result = innerTryLock(lockKey);  
                    if (result) {  
                        break;  
                    } else {  
                        System.out.println("Try to get the Lock,and wait 100 millisecond....");  
                        Thread.sleep(100);  
                    }  
                }  
            }  
            return result;  
        } catch (Exception e) {  
            System.out.println("Failed to run DistributedLockHandler.getLock method."+ e);  
            return false;  
        }  
    }  
      
    /** 
     * 釋放鎖 
     * @param lockKey 鎖的名字 
     */  
    public void realseLock(String lockKey) {  
        if(!checkIfLockTimeout(System.currentTimeMillis(), lockKey)){  
            jedis.del(lockKey);  
        }  
    }  
      
    /** 
     * 內部獲取鎖的實現方法 
     * @param lockKey 鎖的名字 
     * @return 
     */  
    private boolean innerTryLock(String lockKey) {  
          
        long currentTime = System.currentTimeMillis();//當前時間  
        String lockTimeDuration = String.valueOf(currentTime + Lock_Timeout + 1);//鎖的持續時間  
        Long result = jedis.setnx(lockKey, lockTimeDuration);  
          
        if (result == 1) {  
            return true;  
        } else {  
            if (checkIfLockTimeout(currentTime, lockKey)) {  
                String preLockTimeDuration = jedis.getSet(lockKey, lockTimeDuration);  
                if (currentTime > Long.valueOf(preLockTimeDuration)) {  
                    return true;  
                }  
            }  
            return false;  
        }  
          
    }  
  
    /** 
     * 判斷加鎖是否超時 
     * @param currentTime 當前時間 
     * @param lockKey 鎖的名字 
     * @return 
     */  
    private boolean checkIfLockTimeout(Long currentTime, String lockKey) {  
        if (currentTime > Long.valueOf(jedis.get(lockKey))) {//當前時間超過鎖的持續時間  
            return true;  
        } else {  
            return false;  
        }  
    }  
  
    public DistributedLockHandler setJedis(Jedis jedis) {  
        this.jedis = jedis;  
        return this;  
    }  
}  

上述代碼已完整實現基於redis setnx的分佈式鎖，不過該鎖機制是不可重入的，與juc中ReentrantLock 可重入鎖仍存在距離，以後再分章節實現基於setnx的可重入鎖。

參考:1. http://redis.io/commands/setnx2. http://redis.io/topics/distlock---------------------