分布式鎖的三種實作方式

一、zookeeper

1、實作原理：

基于zookeeper瞬時有序節點實作的分布式鎖，其主要邏輯如下（該圖來自于IBM網站）。大緻思想即為：每個用戶端對某個功能加鎖時，在zookeeper上的與該功能對應的指定節點的目錄下，生成一個唯一的瞬時有序節點。判斷是否擷取鎖的方式很簡單，隻需要判斷有序節點中序号最小的一個。當釋放鎖的時候，隻需将這個瞬時節點删除即可。同時，其可以避免服務當機導緻的鎖無法釋放，而産生的死鎖問題。

2、優點

鎖安全性高，zk可持久化

3、缺點

性能開銷比較高。因為其需要動态産生、銷毀瞬時節點來實作鎖功能。

4、實作

可以直接采用zookeeper第三方庫curator即可友善地實作分布式鎖。以下為基于curator實作的zk分布式鎖核心代碼：

Java代碼  

1. @Override  
2. public boolean tryLock(LockInfo info) {  
3.     InterProcessMutex mutex = getMutex(info);  
4.     int tryTimes = info.getTryTimes();  
5.     long tryInterval = info.getTryInterval();  
6.     boolean flag = true;// 代表是否需要重試  
7.     while (flag && --tryTimes >= 0) {  
8.         try {  
9.             if (mutex.acquire(info.getWaitLockTime(), TimeUnit.MILLISECONDS)) {  
10.                 LOGGER.info(LogConstant.DST_LOCK + "acquire lock successfully!");  
11.                 flag = false;  
12.                 break;  
13.             }  
14.         } catch (Exception e) {  
15.             LOGGER.error(LogConstant.DST_LOCK + "acquire lock error!", e);  
16.         } finally {  
17.             checkAndRetry(flag, tryInterval, tryTimes);  
18.         }  
19.     }  
20.     return !flag;// 最後還需要重試，說明沒拿到鎖  
21. }  

2. public boolean releaseLock(LockInfo info) {  
9.             mutex.release();  
10.             LOGGER.info(LogConstant.DST_LOCK + "release lock successfully!");  
11.             flag = false;  
12.             break;  
14.             LOGGER.error(LogConstant.DST_LOCK + "release lock error!", e);  

1. /** 
2.      * 擷取鎖。此處需要加同步，concurrentHashmap無法避免此處的同步問題 
3.      * @param info 鎖資訊 
4.      * @return 鎖執行個體 
5.      */  
6.     private synchronized InterProcessMutex getMutex(LockInfo info) {  
7.         InterProcessReadWriteLock lock = null;  
8.         if (locksCache.get(info.getLock()) != null) {  
9.             lock = locksCache.get(info.getLock());  
10.         } else {  
11.             lock = new InterProcessReadWriteLock(client, BASE_DIR + info.getLock());  
12.             locksCache.put(info.getLock(), lock);  
14.         InterProcessMutex mutex = null;  
15.         switch (info.getIsolate()) {  
16.         case READ:  
17.             mutex = lock.readLock();  
19.         case WRITE:  
20.             mutex = lock.writeLock();  
22.         default:  
23.             throw new IllegalArgumentException();  
25.         return mutex;  

2.  * 判斷是否需要重試 
3.  * @param flag 是否需要重試标志 
4.  * @param tryInterval 重試間隔 
5.  * @param tryTimes 重試次數 
6.  */  
7. private void checkAndRetry(boolean flag, long tryInterval, int tryTimes) {  
8.     try {  
9.         if (flag) {  
10.             Thread.sleep(tryInterval);  
11.             LOGGER.info(LogConstant.DST_LOCK + "retry getting lock! now retry time left: " + tryTimes);  
13.     } catch (InterruptedException e) {  
14.         LOGGER.error(LogConstant.DST_LOCK + "retry interval thread interruptted!", e);  

二、memcached分布式鎖

memcached帶有add函數，利用add函數的特性即可實作分布式鎖。add和set的差別在于：如果多線程并發set，則每個set都會成功，但最後存儲的值以最後的set的線程為準。而add的話則相反，add會添加第一個到達的值，并傳回true，後續的添加則都會傳回false。利用該點即可很輕松地實作分布式鎖。

并發高效。

（1）memcached采用列入LRU置換政策，是以如果記憶體不夠，可能導緻緩存中的鎖資訊丢失。

（2）memcached無法持久化，一旦重新開機，将導緻資訊丢失。