分布式锁实现之Zookeeper之自己封装

我们前面介绍了Zookeeper实现分布式锁的原理，也看了官方是如何实现的，那么我们就按照这个思路来自己实现，我们主要用到了CountDownLatch来实现监听器的功能，当一个节点被删除之后，他们让它后面的那个节点的计数减一，达到通知的功能：

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>();

这是一个分布式锁的信息

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();
		 }
	 }

在构造函数中传入了锁的根目录的名字以及配置信息，得到一个客户端之后，根据lockName创建一个根节点：

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;
	 }

首先会为当前线程创建一个节点，然后获取相同锁空间下的所有节点，判断自己是否是第一个，如果是，那么成功获取到锁，否则获得它的前一个节点，等待它释放锁

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();
		 }
	 }

解锁的时候会删除当前节点，同时子节点的监听器会监听的这个事件，然后唤醒自己获取锁