1. Distributed lock case implemented by native Zookeeper

1) Distributed lock implementation

public class DistributedLock {
    private final String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
    private final int sessionTimeout = 2000;
    private final ZooKeeper zk;

    private CountDownLatch connectLatch = new CountDownLatch(1);
    private CountDownLatch waitLatch = new CountDownLatch(1);

    private String waitPath;
    private String currentNode;

    public DistributedLock() throws IOException, InterruptedException, KeeperException {
        //Get connection
        zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                //connectLatch can be released if zk it is connected
                //Note that the package guided by Event is Zookeeper
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected){
                    connectLatch.countDown();
                }

                //Watchlatch needs to be released
                //If the event of deleting a node occurs and the deleted path is the path of the monitored node, it is released
                if (watchedEvent.getType() == Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)){
                    waitLatch.countDown();
                }
            }
        });

        //After waiting for zk normal connection, go to the next procedure
        connectLatch.await();

        //Determine whether the root node / locks exists
        Stat stat = zk.exists("/locks", false);

        if(stat == null){
            //Create root node
            zk.create("/locks", "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }

    }

    //Lock zk
    public void zklock(){
        //Create the corresponding temporary node with sequence number
        try {
            //The create method returns the node path. Here is the current node
            currentNode = zk.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

            //Judge whether the created node is the smallest sequence number node. If so, obtain the lock; If not, listen to the previous node of its serial number
            List<String> children = zk.getChildren("/locks", false);
            //If children have only one node, get the value directly. If there are multiple nodes, you need to judge who has the smallest serial number
            if(children.size() == 1){
                return;
            }else{
                //Sort by sequence number
                Collections.sort(children);

                //Get node name seq-00000000
                //Cut off / locks / and the rest is the name
                String thisNode = currentNode.substring("/locks/".length());

                //Get the position of the node in the children collection through seq-00000000
                int index = children.indexOf(thisNode);

                //Determine whether there is a problem with the data
                if(index == -1){
                    System.out.println("Data exception");
                }else if(index == 0){
                    //The first node can obtain the lock
                    return;
                }else{
                    //You need to listen for the change of the previous node
                    //waitPath is the previous path of the current node
                    waitPath = "/locks/" + children.get(index - 1);
                    zk.getData(waitPath, true, null);

                    //Waiting for listening
                    waitLatch.await();

                    return;
                }
            }

        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    //Unlock
    public void unZklock(){
        //Delete node
        try {
            zk.delete(currentNode, -1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }
}

2) Distributed lock test

(1) Create two threads

public class DistributedLockTest {
    public static void main(String[] args) throws InterruptedException, IOException, KeeperException {
        final DistributedLock lock1 = new DistributedLock();

        final DistributedLock lock2 = new DistributedLock();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock1.zklock();
                    System.out.println("Thread 1 acquire lock");
                    Thread.sleep(5 * 1000);

                    lock1.unZklock();
                    System.out.println("Thread 1 release lock");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock2.zklock();
                    System.out.println("Thread 2 acquire lock");
                    Thread.sleep(5 * 1000);

                    lock2.unZklock();
                    System.out.println("Thread 2 release lock");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

2. Case of distributed lock implemented by cursor framework

1) Problems in the development of native Java API