zookeeper实现分布式锁

首先我们需要搭建至少三台zookeeper服务器，并且配置好，然后才能成功启动zookeeper。

zookeeper主要作用是存储管理节点和监听节点。实现分布式锁的核心就是利用存储临时节点，监听事件去对锁进行控制。

模拟流程（模拟100个线程进行创建订单号的操作，必须要确保订单号不一样）：

第一步：线程去生成订单号
第二步：首先在zookeeper中创建指定临时节点，设置监听，创建成功则返回true，创建失败则返回false
第三步：根据返回的值去是否生成订单号，如果是true则生成订单号，false则调用zookeeper的监听
第四步：当订单号生成完毕过后，关闭zookeeper连接，会自动删除掉临时节点，删除节点时会触发监听事件，其他的线程收到删除的消息过后，又会去创建临时节点，创建成功的则返回true进行第三步。

说明：在实际过程中，会存在情况：一个线程在创建时，有多个线程在等待，释放锁时，等待的线程都会触发响应事件，就看谁先去创建临时节点成功。

首先创建一个生成订单号规则的class

public class OrderNumGenerator {
	private static int count = 0;

	//生成订单号规则方法
	public String orderNumber() {
		SimpleDateFormat simpt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
		return simpt.format(new Date()) + "-" + ++count;
	}
}

创建锁的操作接口

public interface Lock {
    //获取到锁的资源
	public void getLock();
    // 释放锁
	public void unLock();
}

创建实现操作的抽象类，集成接口 使用抽象类的原因是采用模版设计模式（ 好处：灵活，重构代码 ，扩展）

//将重复的代码,具体业务逻辑有子类去实现.
public abstract class ZookeeperAbstractLock implements Lock {
	private static final String CONNECT_ADDRES = "192.168.110.159:2181,192.168.110.160:2181,192.168.110.162:2181";
	protected ZkClient zkClient = new ZkClient(CONNECT_ADDRES);
	protected static final String PATH = "/lock";

        //得到锁
	public void getLock() {
		// tryLock() 创建zk临时节点 如果创建成功（获得锁）返回true 否则返回false（没有获得）
		if (tryLock()) {
			System.out.println("获取到锁的资源 get lock");
		} else {
			// 等待，等待方法里面有对节点的监听。好好看里面，难点
			waitLock();
			// 重写获取锁的资源
			getLock();
		}

	}

        //尝试去创建节点（获得锁），返回true或者false
	protected abstract boolean tryLock();

        //等待锁的释放
	protected abstract void waitLock();

	// 释放锁，会触发监听
	public void unLock() {
		if (zkClient != null) {
			zkClient.close();
		}
		System.out.println("释放锁的资源..");
	}

}

后面写一个类集成抽象类并实现里面的方法

public class ZookeeperDistrbuteLock extends ZookeeperAbstractLock {

        //创建一个计数器辅助工具
	private CountDownLatch countDownLatch = null;
        
        //尝试去创建节点（获得锁），返回true或者false
	@Override
	protected boolean tryLock() {
		try {
                        //创建临时节点
			zkClient.createEphemeral(PATH);
			return true;
		} catch (Exception e) {
		e.printStackTrace();
			return false;
		}
	}

        
	@Override
	protected void waitLock() {
                //创建一个zookeeper监听事件，ZookeeperAbstractLock这里面删除的时候会触发
		IZkDataListener zkDataListener = new IZkDataListener() {
			// 节点被删除的时候 事件通知
			public void handleDataDeleted(String path) throws Exception {
				// 唤醒被等待的线程
				if (countDownLatch != null) {
                                        //countDownLatch辅助工具down掉，之后其他节点就可以获取了
					countDownLatch.countDown();
				    System.out.println("删除节点.....");
				}
			}
                        // 节点被更新的时候 事件通知（这里不用）
			public void handleDataChange(String path, Object data) throws Exception {
			}
		};

		// 注册到zkclient进行监听
		zkClient.subscribeDataChanges(PATH, zkDataListener);
                //判断有没有这个节点
		if (zkClient.exists(PATH)) {
                        //有的话就实例化
			countDownLatch = new CountDownLatch(1);
			try {
                                //等待
				countDownLatch.await();
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		// 这里countDownLatch.await();中就能确保这个线程完了会有另外一个线程获取到，最后在这里删除监听
		zkClient.unsubscribeDataChanges(PATH, zkDataListener);
	}

}

生成订单号的主类（一百个线程）

//订单服务
public class OrderService implements Runnable {
	private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
	private static Object oj = new Object();
	private Lock lock=new ZookeeperDistrbuteLock();

	public void run() {
		getNumber();
	}

	public void getNumber() {
		// synchronized (oj) {
                //上锁
		lock.getLock();
		String number = orderNumGenerator.orderNumber();
		System.out.println(Thread.currentThread().getName() + ",生成订单号:" + number);
                //释放锁
		lock.unLock();

	}

	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
                        //创建100个线程并启动
			new Thread(new OrderService()).start();
		}
	}
}

这里就会发现订单号完全是按照顺序出来的，而且不会有重复！！！