使用zk实现分布式锁原理代码浅析

• 主要原理：

创建一个带序号的临时node，并获取它，这里命名为nowNode
获取整个父node的所有子node
若是nowNode是子node的第一个，则认为它成功获取到锁
若不是第一个，证明在它前面有着别的线程注册了锁，所以开启监听它的上一个node

问：如何知道nowNode是第几个

带序号的字符串也是可以排序的，通过将获取到的子列表进行排序，即可知道是第几个

以下是实现的代码，主要用于帮助理解思想，课程在b站尚硅谷

import org.apache.zookeeper.*;

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

/** * @author lyb * @Date: 创建于 18:09 2021/9/26 * @说明: */
public class ZkLocks {
    
    /** * zk客户端 */
    private final ZooKeeper ZK;
    /** * zk用户传进来的节点,使用写死的也可,主要是原理方面理解 */
    private final String node;
    /** * 上一个节点,主要用于监听,在函数回调时,释放await */
    private String lastNode;
    private final CountDownLatch countDownLatch = new CountDownLatch(1);
    private final CountDownLatch waitDownLatch = new CountDownLatch(1);
    /** * 当前节点 */
    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;
        //等待zk连接成功
        countDownLatch.await();
        //判断zk路径是否存在
        if (ZK.exists(node, false) == null) {
    
            //不存在,则创建根节点
            ZK.create(node, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }

    }

    public void getLock() throws Exception {
    
        //创建一个带序号的临时节点,序号是原子递增的,可以排序
        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;
        //先排序
        Collections.sort(childrenList);
        int index = childrenList.indexOf(nowNode.split("/")[2]);
        if (index == -1) {
    
            throw new Exception("节点出错");
        }
        //是第一个
        if (index == 0) {
    
            return;
        }
        //监听上一个节点的变化
        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();
            }
        }
    }
}

测试类

/** * @author lyb * @Date: 创建于 19:07 2021/9/26 * @说明: */
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("连接完毕");
        new Thread(() -> {
    
            try {
    
                locks1.getLock();
                System.out.println("线程1获取到锁");
                Thread.sleep(3000);
                System.out.println("线程1释放锁");
                locks1.unLock();
            } catch (Exception e) {
    
            }
        }).start();

        new Thread(() -> {
    
            try {
    
                locks2.getLock();
                System.out.println("线程2获取到锁");
                Thread.sleep(3000);
                System.out.println("线程2释放锁");
                locks2.unLock();
            } catch (Exception e) {
    
            }
        }).start();
        Thread.sleep(1000000000);
    }
}