最新ZooKeeper分布式锁(1)，2024年最新74道高级大数据开发面试合集

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

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

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

package com.test;


import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.zookeeper.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.stream.Collectors;

public class ZookeeperLock implements Lock {

    private static ThreadLocal<String> lockNodePathThreadLocal = new ThreadLocal<>();
    private final ZooKeeper zooKeeper;
    private final String basePath;
    private final String lockName;
    private final String pathSeparator = "/";
    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();


![img](https://img-blog.csdnimg.cn/img_convert/8ad9f9ce4ce2656f6a4fb4624d637659.png)
![img](https://img-blog.csdnimg.cn/img_convert/9810f93c5fb22ca6eb7b0f43d5e521af.png)
![img](https://img-blog.csdnimg.cn/img_convert/9808836d15972357ca383b3fa7aeefc9.png)

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

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.youkuaiyun.com/topics/618545628)**

真正体系化！**

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.youkuaiyun.com/topics/618545628)**