zookeeper分布式锁

<dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.8</version>
</dependency>

// 订单号生成工具类
public class OrderNumGenerateUtil
{
    private static int number = 0;

    public String getOrderNumber()
    {
        return ""+(++number);
    }
}


/**
 * @author tanglei
 */
 // 测试分布式锁
public class OrderService {
    OrderNumGenerateUtil orderNumGenerateUtil = new OrderNumGenerateUtil();

    //Lock lock = new ReentrantLock();
    ZkLock zkLock = new ZkDistributedLock();

    public void getOrderNumber(){
        zkLock.lock();
        try {
            System.out.println("订单编号 :    \t"+orderNumGenerateUtil.getOrderNumber());
        }finally {
            zkLock.unlock();
        }
    }


    public static void main(String[] args) {
        for (int i = 1; i <=20 ; i++) {
            new Thread(()->{
                new OrderService().getOrderNumber();
            },String.valueOf(i)).start();
        }
    }

}


//==================================================================================================

// 下面是封装zookeeper分布式锁的代码,分别从接口,抽象类,到实现类



/**
 * @author tanglei
 */
public class ZkDistributedLock extends ZKAbstractTemplateLock {

    public boolean tryLock() {
        try {
            zkClient.createEphemeral(path);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    public void waitLock() {
        IZkDataListener iZkDataListener = new IZkDataListener() {
            // 节点内容发生变化你需要干什么
            public void handleDataChange(String s, Object o) throws Exception {

            }
            // 删除节点你需要干什么
            public void handleDataDeleted(String s) throws Exception {
                if(countDownLatch!=null){
                    countDownLatch.countDown();
                }
            }
        };

        // 对当前节点发生变换的监听
        zkClient.subscribeDataChanges(path,iZkDataListener);

        if(zkClient.exists(path)){

            // 不能干任何事情,必须等待path也即临时节点被删除后才能继续向下运行
            // 让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。倒计时锁
            countDownLatch = new CountDownLatch(1);
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        zkClient.unsubscribeDataChanges(path,iZkDataListener);

    }



/**
 * @author tanglei
 */
public abstract class ZkAbstractTemplateLock implements ZkLock {
    public final  static String ZKSERVER = "192.168.43.166:2181";

    public static final int TIME_OUT = 1 * 1000;

    ZkClient zkClient = new ZkClient(ZKSERVER,TIME_OUT);

    protected String path = "/myZkLock";

    protected CountDownLatch countDownLatch = null;


    @Override
    public void lock() {
        if(tryLock()){
            System.out.println(Thread.currentThread().getName()+"\t 抢占锁成功");
        }else {
            waitLock();
            lock();
        }
    }
    //模板设计模式,固定化的流程升级到父类定死规范,但是,具体落地实现方法下放给子类各自实现

    public abstract boolean tryLock();
    public abstract void waitLock();


    @Override
    public void unlock() {
        if(zkClient!=null){
            //相当于在zkClient 执行 quit命令
            zkClient.close();
        }
        System.out.println(Thread.currentThread().getName()+"\t 释放锁成功");
        System.out.println();
        System.out.println();
    }
}






/**
 * @author tanglei
 */
public interface ZkLock {

    public void lock();

    public void unlock();

}