一.zookeeper是一款分佈式協調框架，簡單的說，zookeeper=文件系統+通知機制。，主要作用：1.命名服務 2.配置管理（數據發佈與訂閱） 3.集羣管理 4.分佈式鎖 5.隊列管理。
我最開始瞭解zookeeper是源於我們的RPC框架Pigeon，裏面使用它作爲協調管理工具，管理服務實現者和服務請求者。本機下載安裝zookeeper還是挺容易的，參考http://blog.csdn.net/leiyu231/article/details/52292373。我的mac配置文件在：/usr/local/etc/zookeeper。
二.實現分佈式鎖常用三種方式：1）數據庫實現 2）redis實現 3）zookeeper實現。
下面就來實現基於zookeeper實現的分佈式鎖。流程如下：
<1>所有客戶端創建自己的鎖節點
<2>從 Zookeeper 端獲取 /share_lock 下所有的子節點
<3>判斷自己創建的鎖節點是否可以獲取鎖，如果可以，持有鎖。否則對自己關心的鎖節點設置 watcher
<4>持有鎖的客戶端刪除自己的鎖節點，某個客戶端收到該節點被刪除的通知，並獲取鎖
<5>重複步驟4，直至無客戶端在等待獲取鎖了
流程圖如下：
實現如下：
加鎖有3個方法，類似於java.util.concurrent.locks.Lock裏面的3個加鎖方法。
import org.apache.commons.lang.StringUtils;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* zookeeper實現分佈式鎖
* Created by zhouyu on 18/2/22.
*/
public class DistributedLock implements Watcher {
/***
* zookeeper默認端口2181
* zookeeper集羣地址
*/
private final static String host = "localhost:2181";
/**
* ZooKeeper對象
*/
private ZooKeeper zk;
/***
* 鎖的對象,競爭的資源
*/
private String lockName;
/***
* 基本路徑,根節點
*/
private String root = "/locks";
/***
* 計數器
*/
private CountDownLatch countDownLatch;
/**
* 當前鎖
*/
private String CURRENT_LOCK;
/**
* 當前鎖的前一個鎖
*/
private String WAIT_LOCK;/**
* 設置標誌位 防止死鎖發生
* */
private boolean flag=true; public DistributedLock(String lockName) { this.lockName = lockName; if (StringUtils.isBlank(lockName)) { throw new IllegalArgumentException("lockName is wrong"); } try { //新建立對象 根節點,並設置watcher zk = new ZooKeeper(host, 3000, this); Stat stat = zk.exists(root, false); //跟節點不存在則新建,永久節點 if (stat == null) { zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } } catch (Exception e) { e.printStackTrace(); } } /** * 加鎖方法 阻塞模式 */ public void lock() { try { if (tryLock()) { System.out.println(Thread.currentThread().getName() + " " + lockName + "獲得了鎖"); } else { // 等待鎖 waitForLock(WAIT_LOCK, 0,false); } } catch (Exception e) { e.printStackTrace(); } } /** * * * @param WAIT_LOCK 需要等待的上一個鎖,如果他被刪除,自己就能獲得鎖 * @param time 執行的等待時間 * @param isWaitForTime 是否根據time等待 * */ private boolean waitForLock(String WAIT_LOCK,long time,boolean isWaitForTime)throws Exception{ Stat stat = zk.exists(root + "/" + WAIT_LOCK, true); if (stat != null) { countDownLatch = new CountDownLatch(1); if(isWaitForTime){ //時間到時,如果計數爲0,則返回true,否則返回false; return countDownLatch.await(time,TimeUnit.MILLISECONDS); }else { countDownLatch.await(); } countDownLatch = null; } return true; } /*** * 釋放鎖 * 就是將自己的臨時子節點刪除 */ public void unlock() { try { System.out.println("釋放鎖 " + CURRENT_LOCK); //-1代表不需要比較version zk.delete(CURRENT_LOCK, -1); CURRENT_LOCK = null; zk.close(); } catch (Exception e) { e.printStackTrace(); } } /*** * 嘗試獲取鎖 * 1次判斷,獲取不到就返回 * 最基本的加鎖方法。 * 建立臨時有序子節點,並判斷該節點是否爲最小的子節點,是就加鎖成功,否則返回 */ public boolean tryLock() throws Exception { CURRENT_LOCK = zk.create(root + "/" + lockName + "_lock_", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); System.out.println(Thread.currentThread().getName() + " :" + CURRENT_LOCK + " 已經創建"); // 取所有子節點 List<String> subNodes = zk.getChildren(root, false); // 取出所有lockName的鎖 List<String> lockObjects = new ArrayList<>(); for (String node : subNodes) { String _node = node.split("_lock_")[0]; if (_node.equals(lockName)) { lockObjects.add(node); } } //排序 Collections.sort(lockObjects); System.out.println(Thread.currentThread().getName() + " 的鎖是 " + CURRENT_LOCK); // 若當前節點爲最小節點，則獲取鎖成功 if (CURRENT_LOCK.equals(root + "/" + lockObjects.get(0))) { return true; } // 若不是最小節點，則找到自己的前一個節點 String prevNode = CURRENT_LOCK.substring(CURRENT_LOCK.lastIndexOf("/") + 1); WAIT_LOCK = lockObjects.get(Collections.binarySearch(lockObjects, prevNode) - 1); return false; } /** * 有時間限制的阻塞式取鎖 * @param time 等待時間數 單位:毫秒 * */ public boolean tryLock(long time)throws Exception{ try { if (tryLock()) { return true; } else { return waitForLock(WAIT_LOCK, time, true); } }catch (Exception e){ e.printStackTrace(); } return false; } /** * 節點監視器 * 監聽子節點的變動, 只有是刪除節點的時候,countDownLatch不會空。 * @param event 監聽事件 */ public void process(WatchedEvent event) { if (this.countDownLatch != null) { this.countDownLatch.countDown(); } flag=false；測試代碼如下：
public static void main(String[] args){
Runnable runnable = new Runnable() {
public void run() {
DistributedLock lock = null;
try {
lock = new DistributedLock("hello");
lock.lock();//阻塞模式
System.out.println(Thread.currentThread().getName() + "正在運行");
} catch (Exception e){
e.printStackTrace();
}finally {
if (lock != null) {
lock.unlock();
}
}
}
};
for (int i = 0; i < 10; i++) {
Thread t = new Thread(runnable);
t.start();
}
}結果如下：可以看出是有序執行
Thread-1 :/locks/hello_lock_0000000663 已經創建
Thread-3 :/locks/hello_lock_0000000665 已經創建
Thread-5 :/locks/hello_lock_0000000664 已經創建
Thread-8 :/locks/hello_lock_0000000666 已經創建
Thread-2 :/locks/hello_lock_0000000668 已經創建
Thread-9 :/locks/hello_lock_0000000667 已經創建
Thread-7 :/locks/hello_lock_0000000669 已經創建
Thread-4 :/locks/hello_lock_0000000671 已經創建
Thread-6 :/locks/hello_lock_0000000670 已經創建
Thread-0 :/locks/hello_lock_0000000672 已經創建
Thread-3 的鎖是 /locks/hello_lock_0000000665
Thread-5 的鎖是 /locks/hello_lock_0000000664
Thread-6 的鎖是 /locks/hello_lock_0000000670
Thread-9 的鎖是 /locks/hello_lock_0000000667
Thread-7 的鎖是 /locks/hello_lock_0000000669
Thread-1 的鎖是 /locks/hello_lock_0000000663
Thread-1 hello獲得了鎖
Thread-1正在運行
釋放鎖 /locks/hello_lock_0000000663
Thread-8 的鎖是 /locks/hello_lock_0000000666
Thread-0 的鎖是 /locks/hello_lock_0000000672
Thread-2 的鎖是 /locks/hello_lock_0000000668
Thread-4 的鎖是 /locks/hello_lock_0000000671
Thread-5正在運行
釋放鎖 /locks/hello_lock_0000000664
Thread-3正在運行
釋放鎖 /locks/hello_lock_0000000665
Thread-8正在運行
釋放鎖 /locks/hello_lock_0000000666
Thread-9正在運行
釋放鎖 /locks/hello_lock_0000000667
Thread-2正在運行
釋放鎖 /locks/hello_lock_0000000668
Thread-7正在運行
釋放鎖 /locks/hello_lock_0000000669
Thread-6正在運行
釋放鎖 /locks/hello_lock_0000000670
Thread-4正在運行
釋放鎖 /locks/hello_lock_0000000671
Thread-0正在運行
釋放鎖 /locks/hello_lock_0000000672參考：
http://blog.csdn.net/leiyu231/article/details/52292373