Zookeeper分布式锁

2019独角兽企业重金招聘Python工程师标准>>>

临时顺序节点  ：同一名称的临时顺序节点，被重复创建时，zk会根据创建的时间顺序给该节点名称进行编号

临时节点、临时顺序节点：   当创建节点的客户端与zookeeper断开连接后，节点都会被删除

zk提供监听机制

一、tryLock

1、创建临时顺序节点（该临时顺序节点要创建在一个永久节点（后称ParentLock）下，因为临时节点下不允许创建子节点：Ephemerals cannot have children），并返回当前节点名称

2、获取ParentLock下面所有的临时顺序节点并排序

3、判断当前节点是否等于第一个子节点

4、是，则获得锁

5、否，获取当前节点的前一个节点，则等待锁

二、waitLock

创建监听器，监听前一个节点的删除动作，并通过CountDownLatch实现阻塞和唤醒

三、unlock

删除临时节点

 

                

package cn.enjoy.zk;

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

package cn.enjoy.zk;


public abstract class AbstractLock  implements  Lock{

    public void getLock() {
        //尝试获得锁资源
        if (tryLock()) {
            System.out.println("##获取lock锁的资源####");
        } else {
            // 等待
            waitLock();
            // 重新获取锁资源
            getLock();
        }

    }

    // 获取锁资源
    public abstract boolean tryLock();

    // 等待
    public abstract void waitLock();
}

package cn.enjoy.zk;

import org.I0Itec.zkclient.IZkDataListener;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;


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

    private String currentPath;//当前请求的节点
    private String beforePath;//当前请求的节点前一个节点

    public ZookeeperDistrbuteLock2() {
        if (!this.zkClient.exists(PATH2)) {
            this.zkClient.createPersistent(PATH2);
        }
    }


    @Override
    public boolean  tryLock() {
        //如果currentPath为空则为第一次尝试加锁，第一次加锁赋值currentPath
        if(currentPath == null || currentPath.length()<= 0){
            //创建一个临时顺序节点
            currentPath = this.zkClient.createEphemeralSequential(PATH2 + '/',"lock");
        }
        //获取所有临时节点并排序，临时节点名称为自增长的字符串如：0000000400
        List<String> childrens = this.zkClient.getChildren(PATH2);
        Collections.sort(childrens);

        if (currentPath.equals(PATH2 + '/'+childrens.get(0))) {//如果当前节点在所有节点中排名第一则获取锁成功
            return true;
        } else {//如果当前节点在所有节点中排名中不是排名第一，则获取前面的节点名称，并赋值给beforePath
            int wz = Collections.binarySearch(childrens,
                    currentPath.substring(7));
            beforePath = PATH2 + '/'+childrens.get(wz-1);
        }
        return false;

    }

    @Override
    public void waitLock() {
        IZkDataListener listener = new IZkDataListener() {

            public void handleDataDeleted(String dataPath) throws Exception {

                if(countDownLatch!=null){
                    countDownLatch.countDown();
                }
            }

            public void handleDataChange(String dataPath, Object data) throws Exception {

            }
        };
        //给排在前面的的节点增加数据删除的watcher,本质是启动另外一个线程去监听前置节点
        this.zkClient.subscribeDataChanges(beforePath, listener);

        if(this.zkClient.exists(beforePath)){
            countDownLatch=new CountDownLatch(1);
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.zkClient.unsubscribeDataChanges(beforePath, listener);
    }


    public void unLock() {
        //删除当前临时节点
        zkClient.delete(currentPath);
        zkClient.close();
    }
}

package cn.enjoy.zk;

import cn.enjoy.simple.OrderNumGenerator;

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

    private Lock lock = new ZookeeperDistrbuteLock2();

    public void run() {
        getNumber();
    }
    public 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("####生成唯一订单号###");
        for (int i = 0; i < 50; i++) {
            //所以每个OrderService实例拥有一个ZookeeperDistrbuteLock2 当第一次加锁的时候currentPath为空 再次唤醒的时候就是非空了
            new Thread(new OrderService()).start();
        }
    }
}

转载于:https://my.oschina.net/u/2351011/blog/3058938