分佈式鎖定義:
分佈式鎖主要用於在分佈式環境中保護跨進程、跨主機、跨網絡的共享資源實現互斥訪問,以達到保證數據的一致性。
工作流程:
1、在zookeeper指定節點(locks)下創建臨時順序節點node_n
2、獲取locks下所有子節點children3、對子節點按節點自增序號從小到大排序
4、判斷本節點是不是第一個子節點,若是,則獲取鎖;若不是,則監聽比該節點小的那個節點的刪除事件
5、若監聽事件生效,則回到第二步重新進行判斷,直到獲取到鎖
import org.apache.zookeeper.*; import org.apache.zookeeper.data.Stat; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; /** * Created by liuyang on 2017/4/20. */ public class DistributedLock implements Lock, Watcher { private ZooKeeper zk = null; // 根節點 private String ROOT_LOCK = "/locks"; // 競爭的資源 private String lockName; // 等待的前一個鎖 private String WAIT_LOCK; // 當前鎖 private String CURRENT_LOCK; // 計數器 private CountDownLatch countDownLatch; private int sessionTimeout = 30000; private List<Exception> exceptionList = new ArrayList<Exception>(); /** * 配置分佈式鎖 * @param config 連接的url * @param lockName 競爭資源 */ public DistributedLock(String config, String lockName) { this.lockName = lockName; try { // 連接zookeeper zk = new ZooKeeper(config, sessionTimeout, this); Stat stat = zk.exists(ROOT_LOCK, false); if (stat == null) { // 如果根節點不存在,則創建根節點 zk.create(ROOT_LOCK, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } } catch (IOException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } catch (KeeperException e) { e.printStackTrace(); } } // 節點監視器 public void process(WatchedEvent event) { if (this.countDownLatch != null) { this.countDownLatch.countDown(); } } public void lock() { if (exceptionList.size() > 0) { throw new LockException(exceptionList.get(0)); } try { if (this.tryLock()) { System.out.println(Thread.currentThread().getName() + " " + lockName + "獲得了鎖"); return; } else { // 等待鎖 waitForLock(WAIT_LOCK, sessionTimeout); } } catch (InterruptedException e) { e.printStackTrace(); } catch (KeeperException e) { e.printStackTrace(); } } public boolean tryLock() { try { String splitStr = "_lock_"; if (lockName.contains(splitStr)) { throw new LockException("鎖名有誤"); } // 創建臨時有序節點 CURRENT_LOCK = zk.create(ROOT_LOCK + "/" + lockName + splitStr, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); System.out.println(CURRENT_LOCK + " 已經創建"); // 取所有子節點 List<String> subNodes = zk.getChildren(ROOT_LOCK, false); // 取出所有lockName的鎖 List<String> lockObjects = new ArrayList<String>(); for (String node : subNodes) { String _node = node.split(splitStr)[0]; if (_node.equals(lockName)) { lockObjects.add(node); } } Collections.sort(lockObjects); System.out.println(Thread.currentThread().getName() + " 的鎖是 " + CURRENT_LOCK); // 若當前節點爲最小節點,則獲取鎖成功 if (CURRENT_LOCK.equals(ROOT_LOCK + "/" + lockObjects.get(0))) { return true; } // 若不是最小節點,則找到自己的前一個節點 String prevNode = CURRENT_LOCK.substring(CURRENT_LOCK.lastIndexOf("/") + 1); WAIT_LOCK = lockObjects.get(Collections.binarySearch(lockObjects, prevNode) - 1); } catch (InterruptedException e) { e.printStackTrace(); } catch (KeeperException e) { e.printStackTrace(); } return false; } public boolean tryLock(long timeout, TimeUnit unit) { try { if (this.tryLock()) { return true; } return waitForLock(WAIT_LOCK, timeout); } catch (Exception e) { e.printStackTrace(); } return false; } // 等待鎖 private boolean waitForLock(String prev, long waitTime) throws KeeperException, InterruptedException { Stat stat = zk.exists(ROOT_LOCK + "/" + prev, true); if (stat != null) { System.out.println(Thread.currentThread().getName() + "等待鎖 " + ROOT_LOCK + "/" + prev); this.countDownLatch = new CountDownLatch(1); // 計數等待,若等到前一個節點消失,則precess中進行countDown,停止等待,獲取鎖 this.countDownLatch.await(waitTime, TimeUnit.MILLISECONDS); this.countDownLatch = null; System.out.println(Thread.currentThread().getName() + " 等到了鎖"); } return true; } public void unlock() { try { System.out.println("釋放鎖 " + CURRENT_LOCK); zk.delete(CURRENT_LOCK, -1); CURRENT_LOCK = null; zk.close(); } catch (InterruptedException e) { e.printStackTrace(); } catch (KeeperException e) { e.printStackTrace(); } } public Condition newCondition() { return null; } public void lockInterruptibly() throws InterruptedException { this.lock(); } public class LockException extends RuntimeException { private static final long serialVersionUID = 1L; public LockException(String e){ super(e); } public LockException(Exception e){ super(e); } } }
public class Test { static int n = 500; public static void secskill() { System.out.println(--n); } public static void main(String[] args) { Runnable runnable = new Runnable() { public void run() { DistributedLock lock = null; try { lock = new DistributedLock("127.0.0.1:2181", "test1"); lock.lock(); secskill(); System.out.println(Thread.currentThread().getName() + "正在運行"); } finally { if (lock != null) { lock.unlock(); } } } }; for (int i = 0; i < 10; i++) { Thread t = new Thread(runnable); t.start(); } }
}