基于zookeeper实现的分布式锁

最新推荐文章于 2021-12-18 16:49:10 发布
最新推荐文章于 2021-12-18 16:49:10 发布
阅读量177 收藏
点赞数
分类专栏： 分布式锁 文章标签： zookeeper 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qrainly/article/details/94993008
版权

目录

摘要

在分布式解决方案中，分布式锁是一个很重要的部分。之前有写过一篇基于redis实现的分布式锁，为了实现在工作项目中生产环境多节点的定时任务抢占触发。前段时间又接手了一个社区项目的模块改版任务，实现需求是，用户通过APP端报名参加茶会活动，需要在报名接口增加一个分布式锁，以保证在并发请求下活动的名额能够正确的扣减。出于这个项目正好用到了zookeeper做服务注册发现中心。于是尝试搞了一下利用zookeeper的临时有序节点实现分布式锁机制。

实现原理

首先，我们知道zookeeper的数据存储结构就像一棵树，由很多节点(Znode)组成。zookeeper的节点共有四种类型，
1、持久节点（PERSISTENT）
2、持久顺序节点（PERSISTENT_SEQUENTIAL）
3、临时节点（EPHEMERAL）
4、临时顺序节点（EPHEMERAL_SEQUENTIAL）
zookeeper分布式锁正好用到的就是临时顺序节点的特性实现的。首先，先创建一个父节点/lock,请求进来创建一个临时顺序节点，然后获取所有子节点，
遍历判断自己是不是序号最小的那个，如果是则获得锁成功。否则就会监控上一个节点，直至上一个节点释放锁删除节点后才会获得锁。

代码实现

1、先定义一个锁接口

/**
 * @author v_liuwen
 * @date 2019-05-30
 */
public interface ILock {
    /**
     * 获取锁
     * @throws ConcurrencyException
     */
    public void acquireLock() throws ConcurrencyException;

    /**
     * 等待获取锁
     * @throws ConcurrencyException
     */
    public void acquireLockWait() throws ConcurrencyException;

    /**
     * 释放锁
     */
    public void releaseLock() ;
}

2、实现锁接口，事先具体逻辑

/**
 * zookeeper 分布式抢占锁
 * @author v_liuwen
 * @date 2019-05-30
 */
public class ZkDistributeLock implements ILock, Watcher {

    /**
     * 日志打印
     */
    private static Logger logger = LoggerFactory.getLogger(ZkDistributeLock.class);

    //计数器
    private CountDownLatch countDownLatch;
    //根节点
    private String ROOT_LOCK = "/lock";
    //等待的前一个锁
    private String WAIT_LOCK;
    //当前锁
    private String CURRENT_LOCK;
    //锁资源
    private String lockName;
    private ZooKeeper zooKeeper = null;
    private int sessionTimeOut = 30000;
    private List<Exception> exceptionList = Lists.newArrayList();
    private static final String ZOOKEEPER_PROPERTITY_PATH = "/application.properties";

    /**
     * 配置分布式锁
     * @param lockName 锁资源
     */
    public ZkDistributeLock(String lockName){
        this.lockName = lockName;
        try{
            //连接zookeeeper
            String config = PropertiesUtils.getProperty("spring.zookeeper.address", ZOOKEEPER_PROPERTITY_PATH);
            zooKeeper = new ZooKeeper(config,sessionTimeOut,this);
            Stat stat = zooKeeper.exists(ROOT_LOCK,false);
            if(stat == null){
                //如果根节点不存在，则创建根节点
                zooKeeper.create(ROOT_LOCK,new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        }catch (IOException | KeeperException | InterruptedException e){
            logger.error(e.getMessage());
        }
    }

    @Override
    public void acquireLock() throws ConcurrencyException {
        if(exceptionList.size() > 0){
            throw new LockException(exceptionList.get(0));
        }
        try{
            if(this.tryLock()){
                System.out.println(Thread.currentThread().getName()+" "+lockName+"获得了锁");
                logger.debug(Thread.currentThread().getName()+" "+lockName+"获得了锁");
                return;
            }
            throw new LockException("获取锁失败！");
        }catch (LockException e){
            logger.error(e.getMessage());
            throw e;
        }
    }

    public boolean tryLock() {
        try{
            String splitStr = "_lock_";
            if(lockName.contains(splitStr)){
                throw new LockException("锁名错误");
            }
            //创建临时有序节点
            CURRENT_LOCK = zooKeeper.create(ROOT_LOCK+"/"+lockName+splitStr,new byte[0],
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println(CURRENT_LOCK+"已经创建");
            logger.debug(CURRENT_LOCK+"已经创建");
            //获取所有子节点
            List<String> subNodes = zooKeeper.getChildren(ROOT_LOCK,false);
            //取出所有locakName的锁
            List<String> lockObjects = Lists.newArrayList();
            subNodes.forEach(s -> {
                String _node = s.split(splitStr)[0];
                if(_node.equalsIgnoreCase(lockName)){
                    lockObjects.add(s);
                }
            });
            Collections.sort(lockObjects);
            System.out.println(Thread.currentThread().getName()+" 的锁是"+CURRENT_LOCK);
            logger.debug(Thread.currentThread().getName()+" 的锁是"+CURRENT_LOCK);
            //若当前节点为最小节点，则获得锁成功
            if(CURRENT_LOCK.equalsIgnoreCase(ROOT_LOCK+"/"+lockObjects.get(0))){
                return true;
            }
            //若不是最小节点，则找到自己的前一个节点
            String preNode = CURRENT_LOCK.substring(CURRENT_LOCK.lastIndexOf("/")+1);
            WAIT_LOCK = lockObjects.get(Collections.binarySearch(lockObjects,preNode)-1);
        }catch (InterruptedException | KeeperException e){
            logger.error(e.getMessage());
        }
        return false;
    }

    /**
     * 等待获取锁
     * @param prev
     * @param waitTime
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    private boolean waitForLock(String prev,long waitTime) throws KeeperException, InterruptedException {
        Stat stat = zooKeeper.exists(ROOT_LOCK+"/"+prev,true);
        if(stat != null){
            System.out.println(Thread.currentThread().getName()+"等待锁"+ROOT_LOCK+"/"+prev);
            logger.debug(Thread.currentThread().getName()+"等待锁"+ROOT_LOCK+"/"+prev);
            this.countDownLatch = new CountDownLatch(1);
            //计数等待，若等到前一个节点消失，则precess中进行countDown,停止等待，获取锁
            this.countDownLatch = null;
            System.out.println(Thread.currentThread().getName()+"等到了锁");
            logger.debug(Thread.currentThread().getName()+"等到了锁");
        }
        return true;
    }

    @Override
    public void acquireLockWait() throws ConcurrencyException {
        if(exceptionList.size() > 0){
            throw new LockException(exceptionList.get(0));
        }
        try{
            if(this.tryLock()){
                System.out.println(Thread.currentThread().getName()+" "+lockName+"获得了锁");
                logger.debug(Thread.currentThread().getName()+" "+lockName+"获得了锁");
                return;
            }else {
                //等待锁
                waitForLock(WAIT_LOCK,sessionTimeOut);
            }
        }catch (InterruptedException | KeeperException e){
            logger.error(e.getMessage());
        }
    }

    @Override
    public void releaseLock() {
        try{
            logger.debug("释放锁"+CURRENT_LOCK);
            System.out.println("释放锁"+CURRENT_LOCK);
            zooKeeper.delete(CURRENT_LOCK,-1);
            CURRENT_LOCK = null;
            zooKeeper.close();
        }catch (InterruptedException | KeeperException e){
            logger.error(e.getMessage());
        }
    }

    /**
     * 节点监视器
     * @param watchedEvent
     */
    @Override
    public void process(WatchedEvent watchedEvent) {
        if(this.countDownLatch != null){
            this.countDownLatch.countDown();
        }
    }
}

3、测试

/**
 * @author v_liuwen
 * @date 2019-05-25
 */
public class Test1 {

    static int n = 500;
    public static void secsKill(){
        System.out.println(--n);
    }

    public static void main(String[] args) {

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                ZkDistributeLock lock = null;
                try{
                    lock = new ZkDistributeLock("activity");
                    lock.acquireLockWait();
                    secsKill();
                    System.out.println(Thread.currentThread().getName()+"正在运行");
                }finally {
                    if(lock != null){
                        lock.releaseLock();
                    }
                }
            }
        };

        for(int i = 0;i<10;i++){
            Thread t = new Thread(runnable);
            t.start();
        }
    }
}

测试打印部分输出

18:38:50.929 [Thread-1-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950009, packet:: clientPath:null serverPath:null finished:false header:: 1,3  replyHeader:: 1,148,0  request:: '/lock,F  response:: s{20,20,1558774399619,1558774399619,0,60,0,0,0,0,129} 
18:38:50.930 [Thread-3-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950001, packet:: clientPath:null serverPath:null finished:false header:: 1,3  replyHeader:: 1,148,0  request:: '/lock,F  response:: s{20,20,1558774399619,1558774399619,0,60,0,0,0,0,129} 
18:38:50.930 [Thread-8-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950005, packet:: clientPath:null serverPath:null finished:false header:: 1,3  replyHeader:: 1,148,0  request:: '/lock,F  response:: s{20,20,1558774399619,1558774399619,0,60,0,0,0,0,129} 
18:38:50.952 [Thread-1-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950009, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,149,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000030 
/lock/activity_lock_0000000030已经创建
18:38:50.955 [Thread-1] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000030已经创建
18:38:50.957 [Thread-4-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950003, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,150,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000031 
18:38:50.958 [Thread-6-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950006, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,151,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000032 
/lock/activity_lock_0000000031已经创建
18:38:50.959 [Thread-3-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950001, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,152,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000033 
18:38:50.958 [Thread-4] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000031已经创建
/lock/activity_lock_0000000032已经创建
18:38:50.962 [Thread-6] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000032已经创建
18:38:50.965 [Thread-8-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950005, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,153,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000034 
18:38:50.971 [Thread-5-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950002, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,154,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000035 
18:38:50.973 [Thread-2-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950004, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,155,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000036 
18:38:50.974 [Thread-0-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950007, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,156,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000037 
18:38:50.975 [Thread-9-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950000, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,157,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000038 
18:38:50.976 [Thread-7-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950008, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,158,0  request:: '/lock/activity_lock_,,v{s{31,s{'world,'anyone}}},3  response:: '/lock/activity_lock_0000000039 
/lock/activity_lock_0000000033已经创建
18:38:50.983 [Thread-3] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000033已经创建
/lock/activity_lock_0000000034已经创建
18:38:50.983 [Thread-8] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000034已经创建
/lock/activity_lock_0000000035已经创建
/lock/activity_lock_0000000036已经创建
/lock/activity_lock_0000000037已经创建
/lock/activity_lock_0000000038已经创建
18:38:50.987 [Thread-5] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000035已经创建
/lock/activity_lock_0000000039已经创建
18:38:50.988 [Thread-7] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000039已经创建
18:38:50.988 [Thread-9] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000038已经创建
18:38:50.988 [Thread-0] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000037已经创建
18:38:50.988 [Thread-2] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - /lock/activity_lock_0000000036已经创建
18:38:50.996 [Thread-6-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950006, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.996 [Thread-1-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950009, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.996 [Thread-8-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950005, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.996 [Thread-4-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950003, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.997 [Thread-3-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950001, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.997 [Thread-5-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950002, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.999 [Thread-7-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950008, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.999 [Thread-9-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950000, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:50.999 [Thread-0-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950007, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
18:38:51.000 [Thread-2-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950004, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,158,0  request:: '/lock,F  response:: v{'activity_lock_0000000030,'activity_lock_0000000032,'activity_lock_0000000031,'activity_lock_0000000034,'activity_lock_0000000033,'activity_lock_0000000036,'activity_lock_0000000035,'activity_lock_0000000038,'activity_lock_0000000037,'activity_lock_0000000039} 
Thread-0 的锁是/lock/activity_lock_0000000037
Thread-2 的锁是/lock/activity_lock_0000000036
18:38:51.002 [Thread-0] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-0 的锁是/lock/activity_lock_0000000037
18:38:51.002 [Thread-2] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-2 的锁是/lock/activity_lock_0000000036
Thread-6 的锁是/lock/activity_lock_0000000032
18:38:51.002 [Thread-6] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-6 的锁是/lock/activity_lock_0000000032
Thread-3 的锁是/lock/activity_lock_0000000033
18:38:51.002 [Thread-3] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-3 的锁是/lock/activity_lock_0000000033
Thread-1 的锁是/lock/activity_lock_0000000030
18:38:51.003 [Thread-1] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-1 的锁是/lock/activity_lock_0000000030
Thread-7 的锁是/lock/activity_lock_0000000039
Thread-1 activity获得了锁
Thread-4 的锁是/lock/activity_lock_0000000031
18:38:51.004 [Thread-4] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-4 的锁是/lock/activity_lock_0000000031
18:38:51.005 [Thread-0-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950007, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000036,T  response:: s{155,155,1562582330950,1562582330950,0,0,0,72069033391095812,0,0,155} 
18:38:51.005 [Thread-6-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950006, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000031,T  response:: s{150,150,1562582330949,1562582330949,0,0,0,72069033391095811,0,0,150} 
18:38:51.006 [Thread-3-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950001, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000032,T  response:: s{151,151,1562582330949,1562582330949,0,0,0,72069033391095814,0,0,151} 
18:38:51.003 [Thread-7] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-7 的锁是/lock/activity_lock_0000000039
Thread-9 的锁是/lock/activity_lock_0000000038
18:38:51.006 [Thread-9] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-9 的锁是/lock/activity_lock_0000000038
Thread-8 的锁是/lock/activity_lock_0000000034
18:38:51.006 [Thread-8] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-8 的锁是/lock/activity_lock_0000000034
Thread-0等待锁/lock/activity_lock_0000000036
18:38:51.007 [Thread-0] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-0等待锁/lock/activity_lock_0000000036
Thread-6等待锁/lock/activity_lock_0000000031
18:38:51.007 [Thread-6] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-6等待锁/lock/activity_lock_0000000031
Thread-3等待锁/lock/activity_lock_0000000032
18:38:51.007 [Thread-3] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-3等待锁/lock/activity_lock_0000000032
18:38:51.004 [Thread-1] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-1 activity获得了锁
499
Thread-1正在运行
Thread-0等到了锁
Thread-5 的锁是/lock/activity_lock_0000000035
Thread-3等到了锁
Thread-6等到了锁
18:38:51.008 [Thread-2-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950004, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000035,T  response:: s{154,154,1562582330949,1562582330949,0,0,0,72069033391095810,0,0,154} 
18:38:51.008 [Thread-4-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950003, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000030,T  response:: s{149,149,1562582330939,1562582330939,0,0,0,72069033391095817,0,0,149} 
18:38:51.009 [Thread-6] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-6等到了锁
498
Thread-6正在运行
18:38:51.009 [Thread-6] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000032
释放锁/lock/activity_lock_0000000032
18:38:51.010 [Thread-7-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950008, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000038,T  response:: s{157,157,1562582330950,1562582330950,0,0,0,72069033391095808,0,0,157} 
18:38:51.011 [Thread-8-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950005, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000033,T  response:: s{152,152,1562582330949,1562582330949,0,0,0,72069033391095809,0,0,152} 
18:38:51.011 [Thread-9-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x1000a676e950000, packet:: clientPath:null serverPath:null finished:false header:: 4,3  replyHeader:: 4,158,0  request:: '/lock/activity_lock_0000000037,T  response:: s{156,156,1562582330950,1562582330950,0,0,0,72069033391095815,0,0,156} 
Thread-2等待锁/lock/activity_lock_0000000035
18:38:51.008 [Thread-1] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000030
释放锁/lock/activity_lock_0000000030
18:38:51.012 [Thread-2] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-2等待锁/lock/activity_lock_0000000035
Thread-2等到了锁
18:38:51.012 [Thread-2] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-2等到了锁
497
Thread-2正在运行
Thread-7等待锁/lock/activity_lock_0000000038
18:38:51.012 [Thread-2] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000036
释放锁/lock/activity_lock_0000000036
18:38:51.012 [Thread-7] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-7等待锁/lock/activity_lock_0000000038
Thread-7等到了锁
18:38:51.012 [Thread-7] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-7等到了锁
496
Thread-7正在运行
18:38:51.012 [Thread-7] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000039
释放锁/lock/activity_lock_0000000039
Thread-8等待锁/lock/activity_lock_0000000033
18:38:51.012 [Thread-8] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-8等待锁/lock/activity_lock_0000000033
Thread-8等到了锁
18:38:51.012 [Thread-8] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-8等到了锁
495
Thread-8正在运行
18:38:51.012 [Thread-8] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000034
释放锁/lock/activity_lock_0000000034
Thread-9等待锁/lock/activity_lock_0000000037
18:38:51.012 [Thread-9] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-9等待锁/lock/activity_lock_0000000037
Thread-9等到了锁
18:38:51.013 [Thread-9] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-9等到了锁
494
Thread-9正在运行
18:38:51.013 [Thread-9] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000038
释放锁/lock/activity_lock_0000000038
18:38:51.008 [Thread-0] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-0等到了锁
493
Thread-0正在运行
18:38:51.013 [Thread-0] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000037
释放锁/lock/activity_lock_0000000037
Thread-4等待锁/lock/activity_lock_0000000030
18:38:51.013 [Thread-4] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-4等待锁/lock/activity_lock_0000000030
Thread-4等到了锁
18:38:51.013 [Thread-4] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-4等到了锁
492
Thread-4正在运行
18:38:51.013 [Thread-4] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000031
释放锁/lock/activity_lock_0000000031
18:38:51.009 [Thread-5] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-5 的锁是/lock/activity_lock_0000000035
18:38:51.009 [Thread-3] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - Thread-3等到了锁
491
Thread-3正在运行
18:38:51.014 [Thread-3] DEBUG top.qrainly.zookeeper.customlock.ZkDistributeLock - 释放锁/lock/activity_lock_0000000033
释放锁/lock/activity_lock_0000000033

4、搞定

持续更新中…

qrainly
关注
专栏目录
Zookeeper_DistributeLock_Demo.zip
06-28
基于zookeeper的分布式锁实现Demo,可以直接使用.一个是初步实现功能,一个是改进可以直接使用的.建议使用改进版
Zookeeper 实现分布式锁
yao_wen_yu的博客
09-26 749
文章目录何为分布式锁？zookeeper 实现分布式锁zookeeper 实现分布式锁实现思路分布式锁案例代码实现 何为分布式锁？ 比如说：“进程一” 在使用该资源的时候，会先去获得锁，“进程一”获得锁之后会对资源保持独占，这样其他进程就无法访问该资源，”进程一“用完该资源之后就会将锁释放，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。我们把在分布式环境下的锁称之为分布式锁 zookeeper 实现分布式锁 为什么要借助 zookeeper 实现
使用zookeeper开发分布式锁组件
闪的博客
01-19 341
最近一个半月一直比较忙，业务中使用了分布式锁来控制操作特定数据，考虑到重用性，使用curator框架封装zookeeper目录获取和释放分布式锁的模块。记录下来，以后就可以封装类似的组件了。 首先还是要把zookeeper安装好，具体步骤就不介绍了。网上很多。 1，先建立连接配置 @Data @ConfigurationProperties(prefix = ZOOKEEPER_CONFI...
java原生锁_zookeeper分布式锁简单实现(原生JavaApi)
weixin_31764625的博客
02-25 87
1 packagecom.karat.cn.zookeeperAchieveLock.javaapilock;23 importorg.apache.zookeeper.CreateMode;4 importorg.apache.zookeeper.KeeperException;5 importorg.apache.zookeeper.ZooDefs;6 importorg.apache.zoo...
Zookeeper及其分布式锁
Joker_Jiang3的博客
07-17 320
Zookeeper及其分布式锁 一、ZooKeeper 数据模型 znode 结构详解 在 zookeeper 中，可以说 zookeeper 中的所有存储的数据是由 znode 组成的，节点也称为 znode，并以 key/value 形式存储数据。 整体结构类似于 linux 文件系统的模式以树形结构存储。其中根路径以 / 开头。 二、Zookeeper session 基本原理 客户端与服务端之间的连接是基于 TCP 长连接，client 端连接 server 端默认的 2181 端口，也就是 se
基于zookeeper实现分布式锁
10-11
zooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是集群的管理者。提供了文件系统和通知机制。...在开发项目的过程中，很多大型项目都是分布式部署的，那么我们现在使用zookeeper实现一个分布式锁。
redis和zookeeper实现分布式锁的区别
01-20
Redis和Zookeeper是两种常用的分布式协调服务，它们都可以用来实现分布式锁，但具体实现方式和特性有所不同。 **Redis分布式锁** Redis作为内存数据库，具有高性能、低延迟的特点，常被用作实现分布式锁。Redis...
吊打面试官之基于zookeeper实现分布式锁源码
03-18
**基于ZooKeeper实现分布式锁的步骤** 1. **连接ZooKeeper**：客户端首先需要连接到ZooKeeper服务器。 2. **创建临时节点**：客户端在预设的节点路径下创建一个临时顺序节点。 3. **获取最小节点**：客户端获取该...
基于Zookeeper实现分布式锁实践教程
04-14
本实践教程将指导你如何利用Zookeeper实现分布式锁，以便在分布式环境中保证资源访问的互斥性。 **1. Zookeeper概述** Zookeeper是一个分布式协调服务，它为分布式应用提供了简单而强大的命名服务、配置管理、集群...
基于Spring-Boot开发，从0到1构建的分布式秒杀系统，基于Zookeeper实现分布式锁，基于 Kafka分布式消息队列
最新发布
01-03
可能秒杀架构原理大家都懂，网上也有不少实现方式，但大多都是文字的描述，告诉你如何如何，什么加锁、缓存、队列之类。但很少全面有的案例告诉你如何去做，既然是从0到1，希望以下代码案例可以帮助到你。当然最终...
ZooKeeper配置
weixin_42270584的博客
06-29 537
ZooKeeper服务命令: 在准备好相应的配置之后，可以直接通过zkServer.sh 这个脚本进行服务的相关操作 启动ZK服务: sh bin/zkServer.sh start 查看ZK服务状态: sh bin/zkServer.sh status 停止ZK服务: sh bin/zkServer.sh stop 重启ZK服务: sh bin/zkServer.sh restart zk客户端命令 ZooKeeper命令行工具类似于Linux的shell环境，不过功
【Zookeeper】zookeeper 原理和应用
人生所向，皆是美好
01-20 526
文章目录1. zookeeper原理解释1.1 集群角色描述1.2 Paxos 算法概述（ZAB协议）1.2.1 zookeeper 的全新集群选主1.2.2 zookeepr 的非全新集群选主1.3 数据同步1.4 zookeeper 工作流程1.4.1 leader 工作流程1.4.2 follower 工作流程1.4.3 observer 工作流程1.4.4 zookeeper 写数据流程2...
一个正常的zookeeper日志
okkeqin的专栏
02-24 7428
2017-02-24 14:39:38.817 INFO [org.apache.zookeeper.ZooKeeper] - Client environment:java.library.path=C:\Program Files\Java\jre1.8.0_102\bin;C:\WINDOWS\Sun\Java\bin;C:\WINDOWS\system32;C:\WINDOWS;C:/Pr
Zookeeper分布式锁
兮遥
12-18 1304
1、分布式锁 在我们进行单机应用开发时，涉及到同步时，我们都是采用synchronized或者Lock方式解决多线程间的共享数据问题。这时多线程的运行都是在一个JVM之下，没有任何问题。 当时我们的应用是分布式集群工作的情况下，属于多JVM下的工作环境，跨JVM之间已经无法通过多线程的锁解决同步问题 这时需要一种更加高级的锁机制，来处理跨机器的进程之间的数据同步问题。 2、分布式锁原理 核心思想：当客户端获取锁，则创建节点，使用完锁，则删除节点 1）客户端获取锁时，在lock(随便哪个)节点下创建临时顺序
zookeeper输出大量debug日志原因分析
热门推荐
珺珺去哪儿
06-02 1万+
今天无意中发现线上tomcat的catalina.out文件输出大量的zookeeper debug信息，以下是日志片段： 10:30:03.973 [localhost-startStop-1-SendThread(10.168.180.94:2181)] DEBUG org.apache.zookeeper.ClientCnxn – Reading reply sessionid:0x2
开发日志 2017年8月31日
在咖啡里溺水的鱼
08-31 2080
今日任务解决Java客户端连接Hbase的问题日志2017年8月31日10:27:09使用Ambari下载的hbase-site.xml作为配置文件运行测试类 @Test public void test2() { try { Configuration conf = HBaseConfiguration.create();
Zookeeper的Java API操作
兮遥
12-07 876
Curator常用操作：创建连接、添加节点、删除节点、修改节点、查询节点、Watch事件监听 首先还是创建项目所需要的环境 1、在IDEA中创建maven工程 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <vers
zookeeper分布式锁原理及实现
孟凡霄
06-14 1032
前言 本文介绍下 zookeeper方式 实现分布式锁 原理简介 zookeeper实现分布式锁的原理就是多个节点同时在一个指定的节点下面创建临时会话顺序节点，谁创建的节点序号最小，谁就获得了锁，并且其他节点就会监听序号比自己小的节点，一旦序号比自己小的节点被删除了，其他节点就会得到相应的事件，然后查看自己是否为序号最小的节点，如果是，则获取锁 docker 安装 zk 下载镜像 docker pull zookeeper 启动镜像 docker run --name z
基于Zookeeper实现分布式锁(三)
青鸟飞鱼
11-16 526
实现分布式锁的方式非常多，zookeeper、redis、数据库等均可。 zookeeper的四种节点类型 1、持久化节点 ：所谓持久节点，是指在节点创建后，就一直存在，直到有删除操作来主动清除这个节点——不会因为创建该节点的客户端会话失效而消失。 2、持久化顺序节点：这类节点的基本特性和上面的节点类型是一致的。额外的特性是，在ZK中，每个父节点会为他的第一级子节点维护一份时序，会...
Zookeeper实现分布式锁详细教程与工具类代码
Zookeeper，作为一个分布式协调服务，提供了丰富的功能，其中包括实现分布式锁的能力。以下是对基于Zookeeper的分布式锁实现的关键知识点和工具类的详细说明： 1. **分布式锁的核心需求**： - 互斥性：同一时刻，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qrainly

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值