Curator的分布式锁 InterProcessMutex.acquire(long time, TimeUnit unit) 解析

最新推荐文章于 2025-03-10 16:17:05 发布
原创 最新推荐文章于 2025-03-10 16:17:05 发布 · 1.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#zookeeper

本文详细介绍了使用Curator实现的Zookeeper分布式锁InterProcessMutex的内部工作原理，包括其成员变量、构造方法和获取锁的流程，特别是acquire(long time, TimeUnit unit)方法的详细步骤，探讨了lock的获取与撤销过程。" 1204926,129049,交易智慧：《Trading For A Living》读后感及交易策略解析,"['交易系统', '市场趋势', '技术分析', '投资策略', '风险管理']

1、分布式锁实例(网上找的)

先声明自己瞎看的。有错误或者啥的欢迎指出。
先看下这个zk分布锁例子

public static void main(String[] args) {
        CuratorFramework curatorFramework  = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181")
                .sessionTimeoutMs(30000).retryPolicy(new ExponentialBackoffRetry(4000,3))
                .build();
        curatorFramework.start();
        //InterProcessMutex这个锁为公平锁可重入锁
        final InterProcessMutex interProcessMutex = new InterProcessMutex(curatorFramework,"/locks");
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            fixedThreadPool.submit(new Runnable() {
                public void run() {
                    boolean flag = false;
                    try {
                        //
                        Thread currentThread = Thread.currentThread();
                        //尝试获取锁，最多等待10秒
                        flag = interProcessMutex.acquire(20, TimeUnit.SECONDS);
                        if(flag){
                            System.out.println("线程"+currentThread.getId()+"获取锁成功");
                        }else{
                            System.out.println("线程"+currentThread.getId()+"获取锁失败");
                        }
                        //模拟业务逻辑，延时4秒
                        Thread.sleep(2000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally{
                        if(flag){
                            try {
                                //释放锁
                                interProcessMutex.release();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            });
        }
    }

2、相关类的成员变量

InterProcessMutex 成员变量

类型名称含义
LockInternalsinternals锁内部构件类
StringbasePath锁节点的根路径
ConcurrentMap<Thread, LockData>threadData锁信息映射表
StringLOCK_NAME常量：lock-
LockDatalockData静态内部类 锁信息

2.1、LockData 成员变量

类型名称含义
ThreadowningThread等待线程
StringlockPath该线程对应的锁节点
AtomicIntegerlockCount获取锁的次数

2.2、 LockInternals 成员变量

类型名称含义
WatcherRemoveCuratorFrameworkclient客户端
StringpathbasePath+lockName
StringbasePath锁节点根路径
LockInternalsDriverdriver驱动
StringlockName锁的名字
AtomicReference < RevocationSpec>revocable撤销事件 里面存了撤销时线程和线程池
CuratorWatcherrevocableWatcher撤销监听器
volatile intmaxLeases同时最多几个。例如读锁同时能有很多，写锁同时只能有一个
Watcherwatcher监听。动作是notifyall()
static final byte[]REVOKE_MESSAGE字符串为 —REVOKE— 的byte数组

3、 InterProcessMutex构造方法

public InterProcessMutex(CuratorFramework client, String path)

client ：客户端
path ：锁路径

几个构造方法最终都会走到下面这个构造方法

 InterProcessMutex(CuratorFramework client, String path, String lockName, int maxLeases, LockInternalsDriver driver){
 		//验证锁路径是否合规
        basePath = PathUtils.validatePath(path);
        //这里maxLeases为1. driver为StandardLockInternalsDriver
        internals = new LockInternals(client, driver, path, lockName, maxLeases);
 }

4、 获取锁的流程图

图片从别人那里拐的。自己画的话，不太行
图片来自
添加链接描述

在这里插入图片描述

接下来主要是分析这一行代码
flag = interProcessMutex.acquire(20, TimeUnit.SECONDS); //获取锁

5、 acquire(long time, TimeUnit unit)

@Override
    public boolean acquire(long time, TimeUnit unit) throws Exception
    {
        return internalLock(time, unit);
    }

private boolean internalLock(long time, TimeUnit unit) throws Exception{
    

        Thread currentThread = Thread.currentThread();
		//当前线程作为键去获取对应的锁信息对象
        LockData lockData = threadData.get(currentThread);
        //获得过锁的话
        if ( lockData != null ){
            // 锁信息对象中锁次数加1    (可重入锁)
            lockData.lockCount.incrementAndGet();
            return true;
        }
		//尝试获取锁  getLockNodeBytes在该类中返回null，子类有其他实现。
        String lockPath = internals.attemptLock(time, unit, getLockNodeBytes());
        //获取到锁的话
        if ( lockPath != null ){
        	//锁信息对象中放入  线程：锁路径
            LockData newLockData = new LockData(currentThread, lockPath);
            //放入  线程：锁信息对象
            threadData.put(currentThread, newLockData);
            return true;
        }
        return false;
    }

5.1、 internals.attemptLock(time, unit, getLockNodeBytes());

String attemptLock(long time, TimeUnit unit, byte[] lockNodeBytes) throws Exception
    {
    	//开始时间。用于internalLockLoop(startMillis, millisToWait, ourPath); 这里去计算时间
        final long      startMillis = System.currentTimeMillis();
        //等待时间
        final Long      millisToWait = (unit != null) ? unit.toMillis(time) : null;
        //如果撤销事件不为空，设置为new byte[0]
        final byte[]    localLockNodeBytes = (revocable.get() != null) ? new byte[0] : lockNodeBytes;
        //重试次数
        int             retryCount = 0;

        String          ourPath = null;
        boolean         hasTheLock = false;
        boolean         isDone = false;
        while ( !isDone )
        {
            isDone = true;

            try
            {
            	//递归创建path路径的临时有序节点，带初始内容，但此时为初始为null
                ourPath = driver.createsTheLock(client, path, localLockNodeBytes);
                //time时间内去获取锁
                hasTheLock = internalLockLoop(startMillis, millisToWait, ourPath);
            }
            catch ( KeeperException.NoNodeException e )
            {
                //当StandardLockInternalsDriver找不到锁节点时引发
				//这可能发生在会话到期等情况下。因此，如果重试允许，请再试一次
                if ( client.getZookeeperClient().getRetryPolicy().allowRetry(retryCount++, System.currentTimeMillis() - startMillis, RetryLoop.getDefaultRetrySleeper()) )
                {
                    isDone = false;
                }
                else
                {
                    throw e;
                }
            }
        }
		//获取到锁返回锁的节点路径，没有返回空
        if ( hasTheLock )
        {
            return ourPath;
        }

        return null;
    }
5.1.1、 driver.createsTheLock(client, path, localLockNodeBytes);

    @Override
    public String createsTheLock(CuratorFramework client, String path, byte[] lockNodeBytes) throws Exception
    {
        String ourPath;
        if ( lockNodeBytes != null )
        {
        	//递归创建临时有序锁节点，并且设置值
            ourPath = client.create().creatingParentContainersIfNeeded().withProtection().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path, lockNodeBytes);
        }
        else
        {
        	//递归创建临时有序锁节点
            ourPath = client.create().creatingParentContainersIfNeeded().withProtection().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path);
        }
        //返回锁节点路径
        return ourPath;
    }
5.1.2、 internalLockLoop(startMillis, millisToWait, ourPath);
private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception{
    	
        boolean     haveTheLock = false;
        boolean     doDelete = false;
        try
        {
        	//有撤销请求
            if ( revocable.get() != null )
            {
            	// 锁节点内容监听 revocableWatcher监听。
            	// revocableWatcher：当变动节点的内容为 __REVOKE__ 就执行 revocable中的定义线程
                client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
            }
			//客户端为started状态，并且没有获得锁
            while ( (client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock )
            {
            	//获取LockInternals类中basePath路径下的所有子节点路径，并且按照截取lock-后面的数字排序
                List<String>        children = getSortedChildren();
                //获取创建的节点名称   
                String              sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash
				//去获取锁  
                PredicateResults    predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
                //获取到锁了设置为true
                if ( predicateResults.getsTheLock() )
                {
                    haveTheLock = true;
                }
                else
                {
                	//上一个获取到锁的节点路径
                    String  previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();

                    synchronized(this)
                    {
                        try 
                        {
                            // 监听上个锁节点。usingWatcher(watcher) 中是notifyall 如果上个锁有变动，并且没超时。监听器就唤醒自己开始获取锁
                            client.getData().usingWatcher(watcher).forPath(previousSequencePath);
                            //设置的等待时间为空或者等待时间还没耗尽就一直wait
                            if ( millisToWait != null )
                            {
                                millisToWait -= (System.currentTimeMillis() - startMillis);
                                startMillis = System.currentTimeMillis();
                                if ( millisToWait <= 0 )
                                {
                                    doDelete = true;    // timed out - delete our node
                                    break;
                                }

                                wait(millisToWait);
                            }
                            else
                            {
                                wait();
                            }
                        }
                        catch ( KeeperException.NoNodeException e ) 
                        {
                            // it has been deleted (i.e. lock released). Try to acquire again
                        }
                    }
                }
            }
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            doDelete = true;
            throw e;
        }
        finally
        {
        	//删除ourpath节点
            if ( doDelete )
            {
                deleteOurPath(ourPath);
            }
        }
        return haveTheLock;
    }
5.1.2.1 predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
@Override
    public PredicateResults getsTheLock(CuratorFramework client, List<String> children, String sequenceNodeName, int maxLeases) throws Exception
    {
    	//获取创建的锁节点在锁集合中的位置
        int             ourIndex = children.indexOf(sequenceNodeName);
        //验证ourIndex是否为-1
        validateOurIndex(sequenceNodeName, ourIndex);
		//当前创建的锁节点位置<1  也就是第0个。则当前线程获取到锁    maxLeases这个是写死的1.
        boolean         getsTheLock = ourIndex < maxLeases;
        //获取到锁的话。pathToWatch为空。没有则监听前一个锁节点。
        String          pathToWatch = getsTheLock ? null : children.get(ourIndex - maxLeases);

        return new PredicateResults(pathToWatch, getsTheLock);
    }

6 互斥锁撤销

可以运行下这个例子
在有线程获取锁后，修改锁内容为LockInternals.REVOKE_MESSAGE，触发监听。
但是我自己现在还没想到哪些场景会有这个情况。

public static void main(String[] args) {
        final CuratorFramework curatorFramework  = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181")
                .sessionTimeoutMs(30000).retryPolicy(new ExponentialBackoffRetry(4000,3))
                .build();
        curatorFramework.start();
        //InterProcessMutex这个锁为公平锁可重入锁
        final InterProcessMutex interProcessMutex = new InterProcessMutex(curatorFramework,"/locks");
        interProcessMutex.makeRevocable(new RevocationListener<InterProcessMutex>() {
            public void revocationRequested(InterProcessMutex forLock) {
                //获取当前节点的名称
                try {
                    Collection<String> nameList = forLock.getParticipantNodes();
                    System.out.println("====撤销事件触发=====:\t"+ Arrays.toString(nameList.toArray(new String[nameList.size()])));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1);
        for (int i = 0; i < 1; i++) {
            fixedThreadPool.submit(new Runnable() {
                public void run() {
                    boolean flag = false;
                    try {
                        Thread currentThread = Thread.currentThread();
                        //
                        //尝试获取锁，最多等待10秒
                        flag = interProcessMutex.acquire(20, TimeUnit.SECONDS);
                        if(flag){
                            System.out.println("线程"+currentThread.getId()+"获取锁成功");
                        }else{
                            System.out.println("线程"+currentThread.getId()+"获取锁失败");
                        }
                        //输出锁根路径下锁有锁节点
                        Collection<String> nameList = interProcessMutex.getParticipantNodes();
                        ArrayList<String> ll = new ArrayList<String>(nameList);
                        System.out.println("=========:\t"+ Arrays.toString(nameList.toArray(new String[nameList.size()])));
                        byte[] data1 = curatorFramework.getData().forPath(ll.get(0));
                        System.out.println(new String(data1));
                        //改变第一个锁节点的值。触发撤销事件
                        //锁节点设值为  LockInternals.REVOKE_MESSAGE 这里不知道为啥报错所有直接写字符串了
                        curatorFramework.setData().forPath(ll.get(0), "__REVOKE__".getBytes("UTF-8"));
                        byte[] data2 = curatorFramework.getData().forPath(ll.get(0));
                        System.out.println(new String(data2));
                        //模拟业务逻辑，延时4秒
                        Thread.sleep(20000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally{
                        if(flag){
                            try {
                                //释放锁
                                interProcessMutex.release();
                                System.out.println("线程"+Thread.currentThread().getId()+"释放锁成功");
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            });
        }
    }

执行效果结果为：
在这里插入图片描述

Curator应用场景(三)-分布式锁InterProcessMutex使用及原理分析
hosaos的博客
04-25 1万+
API说明 InterProcessMutex有两个构造方法 public InterProcessMutex(CuratorFramework client, String path) { this(client, path, new StandardLockInternalsDriver()); } public InterProcessMut...
ZooKeeper ： Curator框架之分布式锁InterProcessMutex
kaven
01-17 2528
InterProcessMutex InterProcessMutex类的源码注释： A re-entrant mutex that works across JVMs. Uses Zookeeper to hold the lock. All processes in all JVMs that use the same lock path will achieve an inter-process critical section. Further, this mutex is “fair” - ea
Curator实现分布式锁的基本原理-InterProcessMutex.acquire
Leon_Jinhai_Sun的博客
01-18 463
// 无限等待 public void acquire() throws Exception{ if ( !internalLock(-1, null) ){ throw new IOException("Lost connection while trying to acquire lock: " + basePath); } } // 限时等待 public boolean acquire(long time, TimeUnit unit) throws Exception.
Apache Curator之InterProcessMutex抢购案例（三）
weixin_30680385的博客
10-26 167
上一节讲了Apache Curator之分布式锁原理（二），在分析InterProcessMutex源码之前，我们先通过一个简单的手机抢购案例更深入理解分布式锁的原理。废话不多说，先上代码： 手机实体Bean类Phone.java：很简单，只有一个number字段，模拟手机库存数量。 1 package com.youguu.skill; 2 3 public class...
Apache Curator之InterProcessMutex源码分析（四）
chuixue24的博客
08-23 467
上篇文章通过秒购的例子对InterProcessMutex锁有了初步认识，本文将通过对源码进行分析带你进入分布式锁的世界。 老规矩先上图，为了更清晰的了解获取锁，释放锁的过程，下图简化了一些细节，使整个流程更加通畅。 下面将逐个方法去分析。 InterProcessMutex.acquire() 1 @Override //获得分布式锁，阻塞 2 ...
基于Zookeeper实现的分布式互斥锁 - InterProcessMutex
weixin_30823833的博客
10-30 339
Curator是ZooKeeper的一个客户端框架，其中封装了分布式互斥锁的实现，最为常用的是InterProcessMutex，本文将对其进行代码剖析 简介 InterProcessMutex基于Zookeeper实现了分布式的公平可重入互斥锁，类似于单个JVM进程内的ReentrantLock(fair=true) 构造函数 123456789101112131...
深度解析Curator分布式锁InterProcessMutex源码
猿上生活
04-26 937
原创不易，转载请注明出处 文章目录前言1.使用demo2.zk的节点类型介绍3.顺序节点演示4.核心原理5.源码分析初始化获取锁释放锁 前言 本文将介绍下基于zk实现的分布式锁InterProcessMutex实现原理，InterProcessMutex 是zk java 客户端curator提供的一个分布式锁工具，本文主要分为5大部分，分别是使用该锁的demo，zk节点类型的介绍，顺序节点介绍，实现该锁的核心原理，最后是源码分析。 1.使用demo curator maven依赖引入 <dep.
ZooKeepe分布式锁——Curator分布式锁源码详解
“实用”是软件压倒一切的要素
05-10 1247
官方文档上这么解释ZooKeeper，它是一个分布式协调框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。 ZooKeeper主要有如下两个核心的概念：文件系统数据结构 + 监听通知机制。
分布式锁3: zk实现分布式锁5 使用中间件curator-interprocessmutex可重入锁
健康平安的活着的专栏
01-06 917
简化了Zookeeper客户端的开发量。Curator解决了很多zookeeper客户端非常底层的细节开发工作，包括连接重连、反复注册wathcer和NodeExistsException异常等。、集群领导选举、共享计数器、缓存机制、分布式队列等)的抽象封装，这些实现都遵循了zk的最佳实践，并考虑了各种极端情况。1.封装ZooKeeper client与ZooKeeper server之间的连接处理。提供了一套Fluent风格的操作API。Zookeeper提供的原生客户端。
InterProcessMutex 类的作用和使用
罪域之骨终成王
08-04 742
InterProcessMutex 类是Curator框架中的一个分布式锁的实现，用于在分布式环境下实现互斥锁。使用 InterProcessMutex 可以确保在分布式环境下对共享资源的互斥访问，避免多个进程或线程同时访问该资源而导致竞态条件的发生。
Zookeeper分布式锁InterProcessMutex源码解析
Hello_noby的博客
01-05 563
目录使用方式基本原理源码解析InterProcessMutex初始化acquire方法 使用方式 用一下别人的图 基本原理 客户端在获取zookeeper分布式锁的时候，实际上是通过在节点下，添加临时顺序节点（CreateMode.EPHEMERAL_SEQUENTIAL）。如果当前节点通过"lock-"后面的序号排序是第一个，那么久可以获取到锁 源码解析 InterProcessMutex初...
【Zookeeper】应用场景：分布式锁 InterProcessMutex 源码分析
A minor
11-11 1853
首先，我们需要明白一个问题，分布式锁是什么？ 同一个JVM进程内，多个线程同步执行 ==> synchronized，Lock等锁 分布式下，不同JVM进程访问同一资源 ==> Redis，Zookeeper等中间件 1.zookeeper实现分布式锁 1.1 同级节点唯一性 因为Zookeeper的同级节点唯一性，所以多个进程来向zookeeper创建一个相同名称节点，只会有一个成功 失败的节点全部通过watcher机制来监听zookeeper这个子节点的变化，一旦监听到该节
分布式锁的几种实现方式
热门推荐
zdy0_2004的专栏
11-07 1万+
转自：http://www.hollischuang.com/archives/1716 目前几乎很多大型网站及应用都是分布式部署的，分布式场景中的数据一致性问题一直是一个比较重要的话题。分布式的CAP理论告诉我们“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。
2024年最全图解curator如何实现zookeeper分布式锁_curator 锁(2)
2401_84182428的博客
05-03 1178
attemptLock()方法有三个入参：long类型的time 和 TimeUnit类型的 unit 共同表示尝试加锁的超时时间，字节数组类型的lockNodeBytes表示锁路径对应的节点值。方法中会级联创建锁路径，即：锁路径的父路径不存在时，会一级一级的创建，而不是像原生的zookeeper create命令一样报错–父路径不存在。LockData是InterProcessMutex的静态内部类，其仅有三个变量：持有锁的线程、锁路径、锁重入的次数；用于记录每个线程持有的锁信息；不加锁成功就一直等待。
分布式锁—Curator的分布式锁
最新发布
dsgdauigfs的博客
03-10 953
然后获取当前客户端线程尝试获取锁时创建的临时顺序节点的名称，再根据名称获取在节点列表中的位置 + 是否可以获取锁 + 前一个节点的路径，也就是获取一个封装好这些信息的PredicateResults对象。当/semaphore/leases目录下的节点发生变化时，那些对该目录进行Watcher监听的客户端就会收到通知，于是就会执行Watcher里的process()方法，唤醒执行wait()时被阻塞的线程，从而让这些没有成功获取Semaphore的Lease的线程继续尝试获取Lease。
Curator实现分布式锁的基本原理
朱培(知浅_ZLH)
07-15 4837
curator是Netflix公司开源的一个ZooKeeper客户端封装。curator 对于锁这块做了一些封装，curator 提供了InterProcessMutex 这样一个 api。除了分布式锁之外，还提供了 leader 选举、分布式队列等常用的功能。本文主要以InterProcessMutex为例，介绍一下这个分布式可重入排它锁的实现原理。 Curator的几种锁方案： InterP...
海豚调度Dolphinscheduler源码分析（三）
Mrerlou的博客
09-27 2408
今天继续分析海豚调度的源码 上回分析的是dolphinscheduler-service模块zookeeper相关的代码 这回分析是dolphinscheduler-server模块zookeeper相关的代码 ZkMasterClient master服务zk客户端类 类继承的关系如下： 这个类的方法如下： 方法介绍： start()根据路径dolphinscheduler/...
Curator源码分析之分布式锁
陌上花开，可缓缓归矣
01-12 3356
Curato介绍 关于什么是Curator，我们看一下官网是怎么说的。 What is Curator? Apache Curator is a Java/JVM client library for Apache ZooKeeper, a distributed coordination service. It includes a highlevel API framework an...
curator——分布式锁的实现与原理
ly199108171231的博客
12-06 907
1.分布式锁 在我们进行单机应用开发，涉及并发同步的时候，我们往往采用synchronized或者Lock的方式来解决多线程间的代码同步问题。但当我们的应用是分布式部署的情况下，那么就需要一种更加高级的锁机制来处理这个进程级别的代码同步问题。那么接下来引出现在比较常用的几种分布式锁实现方案，如下图：   分布式锁的常用实现方案   而在这几次的实现方案也是各有优缺点，对比如下：  ...
基于ZooKeeper与Curator实现分布式锁的节点操作详解
本文将围绕标题“zookeeperDemo”以及描述和标签中的内容，深入剖析 ZooKeeper 的核心知识点，涵盖节点操作、节点类型、数据读写机制、Curator 框架实现分布式锁的原理与实践，并结合实际开发场景进行详细阐述。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值