ZooKeeper分布式锁(1)，2024年最新写得太好了

private Logger logger = LoggerFactory.getLogger(getClass());


public ZookeeperLock(ZooKeeper zooKeeper, String basePath, String lockName) {
    this.zooKeeper = zooKeeper;
    this.basePath = basePath;
    this.lockName = lockName;
    checkLockName(lockName);
    checkBasePath(basePath);
    createBasePathIfNecessary(zooKeeper, basePath);
}

private void checkLockName(String lockName) {
    if(lockName.contains(pathSeparator))
        throw new RuntimeException("invalid lock name, lock name should not contains " + pathSeparator);
}

private void checkBasePath(String basePath) {
    if(!basePath.startsWith(pathSeparator))
        throw new RuntimeException("base path must starts with " + pathSeparator);
    if(!basePath.equals(pathSeparator) && basePath.endsWith("/"))
        throw new RuntimeException("base path should not ends with " + pathSeparator);
}

private void createBasePathIfNecessary(ZooKeeper zooKeeper, String basePath) {
    try {
        String[] nodeNamesInBasePath = Arrays.stream(basePath.split(pathSeparator)).filter(s -> StringUtils.isNotBlank(s)).collect(Collectors.toList()).toArray(new String[0]);
        boolean needCreate = false;
        for (int i = 0; i < nodeNamesInBasePath.length; i++) {
            String[] nodeNames = ArrayUtils.subarray(nodeNamesInBasePath, 0, i + 1);
            String path = pathSeparator + StringUtils.join(nodeNames, pathSeparator);
            if (needCreate || zooKeeper.exists(path, false) == null) {
                needCreate = true;
                zooKeeper.create(path, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException("create zookeeper base dir for lock failed!", e);
    }
}


@Override
public void lock() {
    while (true) {
        try {
            lockInterruptibly();
            return;
        } catch (InterruptedException e) {
            logger.debug(e.getMessage(), e);
        } catch (RuntimeException e) {
            throw e;
        }
    }
}

@Override
public void lockInterruptibly() throws InterruptedException {
    lockInterruptiblyInternal(0, null);
}

@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    lockInterruptiblyInternal(time, unit);
    return true;
}

@Override
public boolean tryLock() {
    try {
        String lockNodePath = createLockNode();
        if (getLockNodePaths().indexOf(lockNodePath) == 0)
            return true;
        removeLockNode();
        return false;
    } catch (InterruptedException e) {
        logger.debug(e.getMessage(), e);
        return false;
    } catch (KeeperException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void unlock() {
    try {
        removeLockNode();
    } catch (KeeperException e) {
        throw new RuntimeException(e);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

@Override
public Condition newCondition() {
    throw new UnsupportedOperationException();
}

private void lockInterruptiblyInternal(long time, TimeUnit unit) throws InterruptedException {
    try {
        String lockNodePath = createLockNode();
        Object lock = new Object();
        synchronized (lock){
            while (true) {
                List<String> lockNodePaths = getLockNodePaths();
                int lockIndex = lockNodePaths.indexOf(lockNodePath);
                if (lockIndex == 0)
                    return;
                zooKeeper.exists(findPreviousLockNodePath(lockNodePaths, lockIndex), event -> {
                    synchronized (lock) {
                        if(event.getType() == Watcher.Event.EventType.NodeDeleted){
                            lock.notifyAll();
                        }
                    }
                });
                lock.wait(time <= 0 ? 0 : unit.toMillis(time));
            }
        }
    } catch (InterruptedException e) {
        throw e;
    } catch (KeeperException e) {
        throw new RuntimeException(e);
    }
}

private String findPreviousLockNodePath(List<String> lockNodePaths, int lockIndex) {
    for (int i = lockIndex - 1; i >= 0; i--) {
        String nodePath = lockNodePaths.get(i);
        if (nodePath.startsWith(buildNodePath(lockName)))
            return nodePath;
    }
    return null;
}

private List<String> getLockNodePaths() throws KeeperException, InterruptedException {
    List<String> lockNodeNames = zooKeeper.getChildren(basePath, null);
    List<String> lockNodePaths = lockNodeNames.stream().map(nodeName -> buildNodePath(nodeName)).collect(Collectors.toList());
    Collections.sort(lockNodePaths);
    return lockNodePaths;
}

private String createLockNode() throws KeeperException, InterruptedException {
    String lockNodePath = zooKeeper.create(buildNodePath(lockName), null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    lockNodePathThreadLocal.set(lockNodePath);
    return lockNodePath;
}

private void removeLockNode() throws InterruptedException, KeeperException {
    String lockNodePath = lockNodePathThreadLocal.get();

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取