ZooKeeper分布式排它锁实现

ZooKeeper的安装和znode的增删改查这里就不说了，这些大家可以看看《从Paxos到ZooKeeper》这本书，讲的很详细，下面只看代码：

package com.test6.zookeeper;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.KeeperException.NodeExistsException;
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 Test1 implements Watcher {
	private static ZooKeeper zk;
	private static String IP = "127.0.0.1:2181";
	private static int time = 5000;
	private static String path = "/zk-lock/lock";
	static CountDownLatch downLatch = new CountDownLatch(1);

	private Test1() {
	};

	static {
		try {
			zk = new ZooKeeper(IP, time, new Test1());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public void process(WatchedEvent event) {
		try {
			// System.out.println("test6 WatchedEvent……");
			if (KeeperState.SyncConnected == event.getState()) {
				if (EventType.None == event.getType()
						&& null == event.getPath()) {
					downLatch.countDown();
				} else if (EventType.NodeCreated == event.getType()) {
					System.out.println("test6 node " + event.getPath()
							+ " created");
					zk.exists(event.getPath(), true);
				} else if (EventType.NodeDeleted == event.getType()) {
					System.out.println("test6 node " + event.getPath()
							+ " deleted");
					getLock(event.getPath());
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static String createNode(String path) throws KeeperException,
			InterruptedException {
		byte[] data = "".getBytes();
		String result = zk.create(path, data, Ids.OPEN_ACL_UNSAFE,
				CreateMode.EPHEMERAL);
		return result;
	}

	public static void deleteNode(String path) throws InterruptedException,
			KeeperException {
		zk.delete(path, 0);
	}

	public static void getLock(String path) throws KeeperException,
			InterruptedException {
		// 如果不存在，则成功创建表示获取了锁，执行业务逻辑 删除节点
		// 如果不存在，创建失败则添加监听
		// 如果存在 则添加监听，如果监听到删除则调用getLock去获取锁
		zk.exists(path, true);
		String result = null;
		try {
			result = createNode(path);
			// 获取锁，处理业务
			doSomething();
		} catch (NodeExistsException e) {
			System.out.println("test6 被占用……");
			zk.exists(path, true);
		}
	}

	public static void doSomething() {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss|SSS");
			String data = sdf.format(new Date());
			System.out.println("test6 获得锁，处理业务逻辑" + data);
			Thread.sleep(0);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				zk.exists(path, true);
				deleteNode(path);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (KeeperException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		downLatch.await();
		System.out.println("test6 begin:" + Thread.currentThread().getId());
		try {
			getLock(path);
		} catch (KeeperException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("test6 end:" + Thread.currentThread().getId());
		Thread.sleep(Integer.MAX_VALUE);
	}

}