基于Zookeeper实现分布式锁

一、什么是分布式锁

        分布式锁一般用在分布式系统或者多个应用中，用来控制同一任务是否执行或者任务的执行顺序。在项目中，部署了多个tomcat应用，在执行定时任务时就会遇到同一任务可能执行多次的情况，我们可以借助分布式锁，保证在同一时间只有一个tomcat应用执行了定时任务。

二、分布式锁常见的实现方案

1、数据库实现分布式锁（不推荐，效率低）。

2、基于Redis实现分布式锁redission（使用setnx非常麻烦，还需要考虑死锁和释放锁的问题）。

3、基于Zookeeper实现分布式锁（推荐），使用临时节点释放锁，效率高、实现简单、失效时间容易控制。

4、Springcloud内置实现全局锁（很少见）。

三、Zookeeper实现分布式锁的原理

        多个jvm同时在zk上创建一个相同路径的节点。因为节点是唯一的，那么如果有多个客户端同时创建，最终成功的只能有一个，其他的都会进行等待，从而实现加锁。当前jvm执行完毕时就会关闭zk会话，临时节点被删除，从而实现释放锁，这时其他jvm就会使用watcher事件通知获取到这一信息从而重新进入获取锁的请求。

四、代码实现

maven依赖

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

创建Lock接口

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

创建ZookeeperAbstractLock.java抽象类

public abstract class ZookeeperAbstractLock implements Lock{
    //zk连接地址
    private static final String CONNECTSTRING = "127.0.0.1:2181";

    //创建zk连接
    protected ZkClient zkClient = new ZkClient(CONNECTSTRING);

    protected static final String PATH = "/lock";

    public void getLock() {
        //1、连接zkClient 在zk上创建一个/lock节点，类型为临时节点
        //2、如果节点创建成功，执行业务逻辑，否则进行等待
        //3、使用事件通知监听该节点是否被删除，如果被删除的话重新进入获取锁的资源
        if(tryLock()){
            System.out.println("##获取lock锁的资源####");
        }else{
            //等待
            waitLock();
            //重新获取锁
            getLock();
        }
    }

    //获取锁
    abstract boolean tryLock();

    //等待锁
    abstract void waitLock();

    public void unLock() {
        if(zkClient!=null){
            zkClient.close();
            System.out.println("释放锁资源...");
        }
    }
}

创建ZookeeperDistributedLock.java

public class ZookeeperDistributedLock extends ZookeeperAbstractLock {
    private CountDownLatch countDownLatch = null;

    //获取锁
    boolean tryLock() {
        try {
            //创建临时节点
            zkClient.createEphemeral(PATH);
            return true;
        } catch (Exception e) {
            //创建节点失败直接走catch
            return false;
        }
    }

    //等待
    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)){
            countDownLatch = new CountDownLatch(1);
            try {
                //程序等待，countDownLatch为0时往下执行
                countDownLatch.await();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        // 删除监听
        zkClient.unsubscribeDataChanges(PATH, iZkDataListener);
    }
}

OrderNumGenerator.java

public class OrderNumGenerator {

	// 生成订单号规则
	private static int count = 0;

	public String getNumber() {
		try {
			Thread.sleep(200);
		} catch (Exception e) {

		}
		SimpleDateFormat simpt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
		return simpt.format(new Date()) + "-" + ++count;
	}

}

使用Zookeeper锁运行效果

public class OrderService implements Runnable {
    private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();

    private Lock lock = new ZookeeperDistributedLock();

    public void run() {
        getNumber();
    }

    private void getNumber() {
        try {
            lock.getLock();
            String number = orderNumGenerator.getNumber();
            System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unLock();
        }
    }

    public static void main(String[] args) {
        System.out.println("####生成唯一订单号###");
//		OrderService orderService = new OrderService();
        for (int i = 0; i < 50; i++) {
            new Thread(new OrderService()).start();
        }
    }
}

运行效果：