Code analysis of distributed lock principle using ZK

• Main principle ：

Create a temporary with serial number node, And get it , It's called nowNode
Get entire parent node All son node
if nowNode Son node One of the first , It is considered that it has successfully obtained the lock
If not the first , Prove that another thread has registered the lock in front of it , So turn on the last one that monitors it node

ask ： How do you know nowNode It's the number one

Strings with ordinal numbers can also be sorted , Sort the obtained sub list , You can know the number of

Here is the code for implementation , Mainly used to help understand ideas , In the course b Standing in Silicon Valley

import org.apache.zookeeper.*;

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

/** * @author lyb * @Date:  Founded in  18:09 2021/9/26 * @ explain : */
public class ZkLocks {
    
    /** * zk client  */
    private final ZooKeeper ZK;
    /** * zk The node passed in by the user , You can also write dead , Mainly understanding the principle  */
    private final String node;
    /** *  Last node , Mainly used for monitoring , On function callback , Release await */
    private String lastNode;
    private final CountDownLatch countDownLatch = new CountDownLatch(1);
    private final CountDownLatch waitDownLatch = new CountDownLatch(1);
    /** *  Current node  */
    private String nowNode;

    public ZkLocks(String iP, String node) throws Exception {
    
        ZK = new ZooKeeper(iP, 10000, new TestWatcher());
        if (node.isEmpty()) {
    
            node = "/";
        } else if (!node.startsWith("/")) {
    
            node = "/" + node;
        }
        this.node = node;
        // wait for zk Successful connection 
        countDownLatch.await();
        // Judge zk Does the path exist 
        if (ZK.exists(node, false) == null) {
    
            // non-existent , Then create the root node 
            ZK.create(node, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }

    }

    public void getLock() throws Exception {
    
        // Create a temporary node with sequence number , The serial number is incremented by atoms , Can sort 
        nowNode = ZK.create(node + "/locks-", null,
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

        List<String> childrenList = ZK.getChildren(node, false);

        if (childrenList.size() == 1) return;
        // Prioritize 
        Collections.sort(childrenList);
        int index = childrenList.indexOf(nowNode.split("/")[2]);
        if (index == -1) {
    
            throw new Exception(" Node error ");
        }
        // Is the first 
        if (index == 0) {
    
            return;
        }
        // Listen for changes in the previous node 
        lastNode = node + "/" + childrenList.get(index - 1);
        ZK.getData(lastNode, true, null);
        waitDownLatch.await();
    }

    void unLock() {
    
        try {
    
            ZK.delete(nowNode, -1);
        } catch (InterruptedException | KeeperException e) {
    
            e.printStackTrace();
        }
    }

    class TestWatcher implements Watcher {
    
        @Override
        public void process(WatchedEvent watchedEvent) {
    
            if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
    
                countDownLatch.countDown();
            }
            if (watchedEvent.getType() == Event.EventType.NodeDeleted &&
                    watchedEvent.getPath().equals(lastNode)) {
    
                waitDownLatch.countDown();
            }
        }
    }
}

Test class

/** * @author lyb * @Date:  Founded in  19:07 2021/9/26 * @ explain : */
public class ZkLockTest {
    
    public static void main(String[] args) throws Exception {
    
        final ZkLocks locks1 = new ZkLocks("127.0.0.1:2181", "/locksTest");
        final ZkLocks locks2 = new ZkLocks("127.0.0.1:2181", "/locksTest");
        System.out.println(" Connection complete ");
        new Thread(() -> {
    
            try {
    
                locks1.getLock();
                System.out.println(" Threads 1 Get lock ");
                Thread.sleep(3000);
                System.out.println(" Threads 1 Release the lock ");
                locks1.unLock();
            } catch (Exception e) {
    
            }
        }).start();

        new Thread(() -> {
    
            try {
    
                locks2.getLock();
                System.out.println(" Threads 2 Get lock ");
                Thread.sleep(3000);
                System.out.println(" Threads 2 Release the lock ");
                locks2.unLock();
            } catch (Exception e) {
    
            }
        }).start();
        Thread.sleep(1000000000);
    }
}