zookeeper实现分布式锁详解

    分布式锁的实现方式有很多，之前介绍过用redis实现分布式锁，这里zookeeper也是一种常见的实现方式。在网上看了很多zookeeper实现分布式锁的例子，几乎都是介绍一个思路，然后附上一段代码，可能都没有运行过。有的是代码实现没有问题，但是示例没有体现出分布式锁的使用结果。

    所谓分布式锁，其实是相对于普通的锁而言的，只不过普通的锁只能是一个进程之内的线程之间共享，当我们的程序部署在不同的机器上的时候，组成了一个分布式系统，这时候，普通的锁就不能达到我们的要求，那么锁资源需要是所有的进程都能够访问，并且只能有一个进程的某一个线程能够获取这个资源，这时候的锁资源，就需要是一个服务，比如mysql，redis，zookeeper甚至只要是能够通过ip和端口能够访问的服务，都可以作为这个锁。

    redis作为分布式锁的实现是使用setnx(key,value)这个操作，就是同一时间，只能有一个进程能够设置成功，其他的进程只能等待这个进程释放锁，也就是delete这个key。

    同样的，如果是mysql，那么可以利用mysql中建表特点，同一时间也是只能有一个进程的建表语句能够建立同一个名称的表，其他的进程会失败，需要等待该进程执行完他的操作然后释放锁，即删除这个表之后，才能继续获取锁，即创建表。

    zookeeper实现分布式锁，也是一样的道理，我们会在同一个路径下创建一批临时节点，这些临时节点是有序列号的，每次只让序列号最小的节点获取锁，其他的节点等待，并且监听比他小的节点删除事件，也是等待锁的过程，当最小的节点获取锁资源，并执行完相关操作，他会释放锁，也就是删除这个临时节点。这时候，注册了这个路径的监听事件的节点会获取锁，还是一样的思路，序列号最小的节点获取锁，依次类推，直到所有的节点均获取锁并执行相关操作。

    zookeeper实现分布式锁的原理这里就介绍完了，zookeeper分布式锁的特点在于，创建的临时节点是唯一的，而且序列号是按照顺序递增的，序列号可以看做是一个长整型数据。

    现在来看通过程序如何实现这个分布式锁，有几个需要注意的地方：

1、默认我们需要在一个路径，比如/root下创建临时节点，而且创建临时节点的路径，我们还需要指定一个容易区分的名称，比如/root/_locknode_，通过api，我们可以如下方式来创建这个临时节点。

2、正常获取锁的逻辑判断很简单，就是通过/root这个路径找到它的所有子节点，然后找到序列号最小的节点即可。

3、如果不是最小节点，那么就需要另行处理了，这里需要等待最小节点释放锁，而按照之前的介绍，下一个获取锁的节点会是最小节点删除之后的节点当中的最小节点，也就是第二小的节点。所以在等待获取锁的过程中，我们需要监听比当前节点还要小的一个节点，而不是所有比当前节点都小的节点。因此，监听节点变化也是一个按照顺序依次监听的过程，_locknode_0000000009监听节点_locknode_0000000008，_locknode_0000000008监听_locknode_0000000007，依此类推，_locknode_0000000001监听_locknode_0000000000，当前一个被监听节点删除的时候，当前节点就获取锁。

4、这里释放锁的过程就显得很重要了，如果释放的不正确，后续的节点就无法按照这个获取锁的逻辑来获取锁了。

5、每一个节点最终释放锁的时候，需要删除该节点，因此我们需要在锁的实体类中定义一个私有变量，记录这个锁的路径，这里以myName为例。

6、当一个节点释放锁资源之后，其他节点监听到变化了，这时候就需要结束等待，并且需要再次获取锁，一般来说，就是需要去抢一次锁资源，就是需要递归调用加锁方法。

  有了这个思路，我们的分布式锁就可以实现了，这里给出一个示例：

  定义一个锁的接口，Lock.java：

package com.xxx.lock3;

public interface Lock {
	void lock();
	void unlock();
}

  实现这个锁，DistributedLock.java

package com.xxx.lock3;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
public class DistributedLock implements Lock{
	private String path = "/root/_locknode_";
	private ZooKeeper zk;
	private static final int sessionTimeout = 6000;
	private CountDownLatch latch = new CountDownLatch(1);
	private String myName;
	
	public DistributedLock(){
		try {
			zk = new ZooKeeper("localhost:2181", sessionTimeout, new Watcher() {	
				@Override
				public void process(WatchedEvent event) {
					if(event.getState()==KeeperState.SyncConnected){
						latch.countDown();
					}
				}
			});
			latch.await();
			myName = zk.create(path, null, Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public void lock() {
		try {
			if(tryLock()){
				System.out.println(Thread.currentThread().getName()+" get lock.");
				return;
			}else{
				waitLock();
				lock();
			}
		} catch (KeeperException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public void unlock() {
		try {
			zk.delete(myName, -1);
			zk.close();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	public boolean tryLock() throws KeeperException, InterruptedException{
		List<String> list = zk.getChildren("/root", false);
		String[] mystr = myName.split("_");
		
		long myId = Long.parseLong(mystr[2]);
		boolean minId = true;
		for(String childName:list){
			String[] childNames = childName.split("_");
			long id = Long.parseLong(childNames[2]);
			if(id<myId){
				minId = false;
				break;
			}
		}
		if(minId)
			return true;
		return false;
	}
	
	public void waitLock(){
		try {
			CountDownLatch latch = new CountDownLatch(1);
			List<String> children = zk.getChildren("/root", false);
			Collections.sort(children);
			String myId = myName.split("/")[2];
			int index = children.indexOf(myId);
			if(index<=0){
				throw new IllegalArgumentException("data error");
			}
			//String headPath = children.get(index-1);
			String headPath = children.get(0);
			zk.exists("/root/"+headPath, new Watcher(){
				@Override
				public void process(WatchedEvent event) {
					if(event.getType()==EventType.NodeDeleted){
						latch.countDown();
					}
				}	
			});
			latch.await();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

  测试程序，启动十个线程，每个线程执行同样的run方法，通过使用分布式锁，我们的代码如下：

package com.xxx.lock3;

public class MainService {

	public static void main(String[] args) {
		for(int i=0;i<10;i++){
			Thread thread = new Thread(new Runnable() {
				Lock lock = new DistributedLock();
				@Override
				public void run() {
					try {
						lock.lock();
						System.out.println(Thread.currentThread().getName()+" start");
						Thread.sleep(200);
						System.out.println(Thread.currentThread().getName()+" end");
					} catch (Exception e) {
						// TODO: handle exception
					}finally{
						lock.unlock();
					}
				}
			});
			thread.start();
		}
	}

}

  运行示例程序，打印结果如下：

    这个示例，虽然是在单机上运行的，但是也能看出来加锁，释放锁期间，只有一个线程在运行，其他的线程均在等待锁的释放，这里的结果也验证了，通过zookeeper实现的分布式锁，加锁释放锁的过程是一个类似塔罗牌的过程，锁的获取顺序是可以预见的。这个代码有一个小问题，就是我这里是默认/root路径时存在的，如果你运行程序发现问题，可以在zookeeper上手工创建/root节点。