返回顶部
首页 > 资讯 > 精选 >基于Zookeeper的分布式锁该如何理解
  • 559
分享到

基于Zookeeper的分布式锁该如何理解

2023-06-04 07:06:25 559人浏览 安东尼
摘要

今天就跟大家聊聊有关基于ZooKeeper的分布式锁该如何理解,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。实现分布式锁目前有三种流行方案,分别为基于数据库、Redis、Zookee

今天就跟大家聊聊有关基于ZooKeeper分布式该如何理解,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。

实现分布式锁目前有三种流行方案,分别为基于数据库Redis、Zookeeper的方案,其中前两种方案网络上有很多资料可以参考,怎么不做展开。我们来看下使用Zookeeper如何实现分布式锁。

什么是Zookeeper?

Zookeeper(业界简称zk)是一种提供配置管理、分布式协同以及命名的中心化服务,这些提供的功能都是分布式系统中非常底层且必不可少的基本功能,但是如果自己实现这些功能而且要达到高吞吐、低延迟同时还要保持一致性和可用性,实际上非常困难。因此zookeeper提供了这些功能,开发者在zookeeper之上构建自己的各种分布式系统。

虽然zookeeper的实现比较复杂,但是它提供的模型抽象却是非常简单的。Zookeeper提供一个多层级的节点命名空间(节点称为znode),每个节点都用一个以斜杠(/)分隔的路径表示,而且每个节点都有父节点(根节点除外),非常类似于文件系统。例如,/foo/doo这个表示一个znode,它的父节点为/foo,父父节点为/,而/为根节点没有父节点。与文件系统不同的是,这些节点都可以设置关联的数据,而文件系统中只有文件节点可以存放数据而目录节点不行。Zookeeper为了保证高吞吐和低延迟,在内存中维护了这个树状的目录结构,这种特性使得Zookeeper不能用于存放大量的数据,每个节点的存放数据上限为1M。

而为了保证高可用,zookeeper需要以集群形态来部署,这样只要集群中大部分机器是可用的(能够容忍一定的机器故障),那么zookeeper本身仍然是可用的。客户端在使用zookeeper时,需要知道集群机器列表,通过与集群中的某一台机器建立tcp连接来使用服务,客户端使用这个TCP链接来发送请求、获取结果、获取监听事件以及发送心跳包。如果这个连接异常断开了,客户端可以连接到另外的机器上。

架构简图如下所示:

基于Zookeeper的分布式锁该如何理解

客户端的读请求可以被集群中的任意一台机器处理,如果读请求在节点上注册了监听器,这个监听器也是由所连接的zookeeper机器来处理。对于写请求,这些请求会同时发给其他zookeeper机器并且达成一致后,请求才会返回成功。因此,随着zookeeper的集群机器增多,读请求的吞吐会提高但是写请求的吞吐会下降。

有序性是zookeeper中非常重要的一个特性,所有的更新都是全局有序的,每个更新都有一个唯一的时间戳,这个时间戳称为zxid(Zookeeper Transaction Id)。而读请求只会相对于更新有序,也就是读请求的返回结果中会带有这个zookeeper最新的zxid。

如何使用zookeeper实现分布式锁?

在描述算法流程之前,先看下zookeeper中几个关于节点的有趣的性质:

  • 有序节点:假如当前有一个父节点为/lock,我们可以在这个父节点下面创建子节点;zookeeper提供了一个可选的有序特性,例如我们可以创建子节点“/lock/node-”并且指明有序,那么zookeeper在生成子节点时会根据当前的子节点数量自动添加整数序号,也就是说如果是第一个创建的子节点,那么生成的子节点为/lock/node-0000000000,下一个节点则为/lock/node-0000000001,依次类推。

  • 临时节点:客户端可以建立一个临时节点,在会话结束或者会话超时后,zookeeper会自动删除该节点。

  • 事件监听:在读取数据时,我们可以同时对节点设置事件监听,当节点数据或结构变化时,zookeeper会通知客户端。当前zookeeper有如下四种事件:1)节点创建;2)节点删除;3)节点数据修改;4)子节点变更。

基于Zookeeper的分布式锁该如何理解

下面描述使用zookeeper实现分布式锁的算法流程,假设锁空间的根节点为/lock:

  1. 客户端连接zookeeper,并在/lock下创建临时的且有序的子节点,第一个客户端对应的子节点为/lock/lock-0000000000,第二个为/lock/lock-0000000001,以此类推。

  2. 客户端获取/lock下的子节点列表,判断自己创建的子节点是否为当前子节点列表中序号最小的子节点,如果是则认为获得锁,否则监听/lock的子节点变更消息,获得子节点变更通知后重复此步骤直至获得锁;

  3. 执行业务代码;

  4. 完成业务流程后,删除对应的子节点释放锁。

步骤1中创建的临时节点能够保证在故障的情况下锁也能被释放,考虑这么个场景:假如客户端a当前创建的子节点为序号最小的节点,获得锁之后客户端所在机器宕机了,客户端没有主动删除子节点;如果创建的是永久的节点,那么这个锁永远不会释放,导致死锁;由于创建的是临时节点,客户端宕机后,过了一定时间zookeeper没有收到客户端的心跳包判断会话失效,将临时节点删除从而释放锁。

另外细心的朋友可能会想到,在步骤2中获取子节点列表与设置监听这两步操作的原子性问题,考虑这么个场景:客户端a对应子节点为/lock/lock-0000000000,客户端b对应子节点为/lock/lock-0000000001,客户端b获取子节点列表时发现自己不是序号最小的,但是在设置监听器前客户端a完成业务流程删除了子节点/lock/lock-0000000000,客户端b设置的监听器岂不是丢失了这个事件从而导致永远等待了?这个问题不存在的。因为zookeeper提供的api中设置监听器的操作与读操作是原子执行的,也就是说在读子节点列表时同时设置监听器,保证不会丢失事件。

最后,对于这个算法有个极大的优化点:假如当前有1000个节点在等待锁,如果获得锁的客户端释放锁时,这1000个客户端都会被唤醒,这种情况称为“羊群效应”;在这种羊群效应中,zookeeper需要通知1000个客户端,这会阻塞其他的操作,最好的情况应该只唤醒新的最小节点对应的客户端。应该怎么做呢?在设置事件监听时,每个客户端应该对刚好在它之前的子节点设置事件监听,例如子节点列表为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002,序号为1的客户端监听序号为0的子节点删除消息,序号为2的监听序号为1的子节点删除消息。

所以调整后的分布式锁算法流程如下:

  • 客户端连接zookeeper,并在/lock下创建临时的且有序的子节点,第一个客户端对应的子节点为/lock/lock-0000000000,第二个为/lock/lock-0000000001,以此类推;

  • 客户端获取/lock下的子节点列表,判断自己创建的子节点是否为当前子节点列表中序号最小的子节点,如果是则认为获得锁,否则监听刚好在自己之前一位的子节点删除消息,获得子节点变更通知后重复此步骤直至获得锁;

  • 执行业务代码;

  • 完成业务流程后,删除对应的子节点释放锁。

Curator的源码分析

虽然zookeeper原生客户端暴露的API已经非常简洁了,但是实现一个分布式锁还是比较麻烦的…我们可以直接使用curator这个开源项目提供的zookeeper分布式锁实现。

我们只需要引入下面这个包(基于Maven):

<dependency>  <groupId>org.apache.curator</groupId>  <artifactId>curator-recipes</artifactId>  <version>4.0.0</version></dependency>

然后就可以用啦!代码如下:

  1. public static void main(String[] args) throws Exception {

  2.  //创建zookeeper的客户端

  3.  RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);

  4.  CuratorFramework client = CuratorFrameworkFactory.newClient("10.21.41.181:2181,10.21.42.47:2181,10.21.49.252:2181", retryPolicy);

  5.  client.start();

  6.  //创建分布式锁, 锁空间的根节点路径为/curator/lock

  7.  InterProceSSMutex mutex = new InterProcessMutex(client, "/curator/lock");

  8.  mutex.acquire();

  9.  //获得了锁, 进行业务流程

  10.  System.out.println("Enter mutex");

  11.  //完成业务流程, 释放锁

  12.  mutex.release();

  13.  //关闭客户端

  14.  client.close();

  15. }

可以看到关键的核心操作就只有mutex.acquire()和mutex.release(),简直太方便了!

下面来分析下获取锁的源码实现。acquire的方法如下:

  1. @Override

  2. public void acquire() throws Exception{

  3.  if ( !internalLock(-1, null) ){

  4.      throw new IOException("Lost connection while trying to acquire lock: " + basePath);

  5.    }

  6. }

这里有个地方需要注意,当与zookeeper通信存在异常时,acquire会直接抛出异常,需要使用者自身做重试策略。代码中调用了internalLock(-1, null),参数表明在锁被占用时永久阻塞等待。internalLock的代码如下

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

  2.    //这里处理同线程的可重入性,如果已经获得锁,那么只是在对应的数据结构中增加acquire的次数统计,直接返回成功

  3.    Thread currentThread = Thread.currentThread();

  4.    LockData lockData = threadData.get(currentThread);

  5.    if (lockData != null) {

  6.        lockData.lockCount.incrementAndGet();

  7.        return true;

  8.    }

  9.    //这里才真正去zookeeper中获取锁

  10.    String lockPath = internals.attemptLock(time, unit, getLockNodeBytes());

  11.    if (lockPath != null) {

  12.        //获得锁之后,记录当前的线程获得锁的信息,在重入时只需在LockData中增加次数统计即可

  13.        LockData newLockData = new LockData(currentThread, lockPath);

  14.        threadData.put(currentThread, newLockData);

  15.        return true;

  16.    }

  17.    //在阻塞返回时仍然获取不到锁,这里上下文的处理隐含的意思为zookeeper通信异常

  18.    return false;

  19. }

代码中增加了具体注释,不做展开。看下zookeeper获取锁的具体实现:

  1. String attemptLock(long time, TimeUnit unit, byte[] lockNodeBytes) throws Exception {

  2.     //参数初始化,此处省略

  3.     //...

  4.     //自旋获取锁

  5.     while (!isDone) {

  6.         isDone = true;

  7.         try {

  8.         //在锁空间下创建临时且有序的子节点

  9.             ourPath = driver.createsTheLock(client, path, localLockNodeBytes);

  10.             //判断是否获得锁(子节点序号最小),获得锁则直接返回,否则阻塞等待前一个子节点删除通知

  11.             hasTheLock = internalLockLoop(startMillis, millisToWait, ourPath);

  12.         } catch (KeeperException.NoNodeException e) {

  13.             //对于NoNodeException,代码中确保了只有发生session过期才会在这里抛出NoNodeException,因此这里根据重试策略进行重试

  14.             if (client.getZookeeperClient().getRetryPolicy().allowRetry(retryCount++, System.currentTimeMillis() - startMillis, RetryLoop.getDefaultRetrySleeper())) {

  15.                 isDone = false;

  16.             } else {

  17.                 throw e;

  18.             }

  19.         }

  20.     }

  21.     //如果获得锁则返回该子节点的路径

  22.     if (hasTheLock) {

  23.         return ourPath;

  24.     }

  25.     return null;

  26. }

上面代码中主要有两步操作:

  • driver.createsTheLock:创建临时且有序的子节点,里面实现比较简单不做展开,主要关注几种节点的模式:1)PERSISTENT(永久);2)PERSISTENTSEQUENTIAL(永久且有序);3)EPHEMERAL(临时);4)EPHEMERALSEQUENTIAL(临时且有序)。

  • internalLockLoop:阻塞等待直到获得锁。

看下internalLockLoop是怎么判断锁以及阻塞等待的,这里删除了一些无关代码,只保留主流程:

  1. //自旋直至获得锁

  2. while((client.getState()==CuratorFrameworkState.STARTED)&&!haveTheLock ){

  3.     //获取所有的子节点列表,并且按序号从小到大排序

  4.     List<String> children = getSortedChildren();

  5.     //根据序号判断当前子节点是否为最小子节点

  6.     String sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash

  7.     PredicateResults predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);

  8.     if (predicateResults.getsTheLock()) {

  9.         //如果为最小子节点则认为获得锁

  10.         haveTheLock = true;

  11.     } else {

  12.         //否则获取前一个子节点

  13.         String previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();

  14.         //这里使用对象监视器做线程同步,当获取不到锁时监听前一个子节点删除消息并且进行wait(),当前一个子节点删除(也就是锁释放)时,

  15.         // 回调会通过notifyAll唤醒此线程,此线程继续自旋判断是否获得锁

  16.         synchronized (this) {

  17.             try {

  18.                 //这里使用getData()接口而不是checkExists()是因为,如果前一个子节点已经被删除了那么会抛出异常而且不会设置事件监听器,

  19.                 // 而checkExists虽然也可以获取到节点是否存在的信息但是同时设置了监听器,这个监听器其实永远不会触发,对于zookeeper来说属于资源泄露

  20.                 client.getData().usingWatcher(watcher).forPath(previousSequencePath);

  21.                 //如果设置了阻塞等待的时间

  22.                 if (millisToWait != null) {

  23.                     millisToWait -= (System.currentTimeMillis() - startMillis);

  24.                     startMillis = System.currentTimeMillis();

  25.                     if (millisToWait <= 0) {

  26.                         doDelete = true; // 等待时间到达,删除对应的子节点

  27.                         break;

  28.                     }

  29.                     //等待相应的时间

  30.                     wait(millisToWait);

  31.                 } else {

  32.                     //永远等待

  33.                     wait();

  34.                 }

  35.             } catch (KeeperException.NoNodeException e) {

  36.                 //上面使用getData来设置监听器时,如果前一个子节点已经被删除那么会抛出NoNodeException,只需要自旋一次即可,无需额外处理

  37.             }

  38.         }

  39.     }

  40. }

代码中设置的事件监听器,在事件发生回调时只是简单的notifyAll唤醒当前线程以重新自旋判断,比较简单不再展开。

看完上述内容,你们对基于Zookeeper的分布式锁该如何理解有进一步的了解吗?如果还想了解更多知识或者相关内容,请关注编程网精选频道,感谢大家的支持。

--结束END--

本文标题: 基于Zookeeper的分布式锁该如何理解

本文链接: https://www.lsjlt.com/news/236945.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 基于Zookeeper的分布式锁该如何理解
    今天就跟大家聊聊有关基于Zookeeper的分布式锁该如何理解,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。实现分布式锁目前有三种流行方案,分别为基于数据库、Redis、Zookee...
    99+
    2023-06-04
  • 基于Zookeeper实现分布式锁详解
    目录1、什么是Zookeeper?2、Zookeeper节点类型3、Zookeeper环境搭建4、Zookeeper基本使用5、Zookeeper应用场景6、Zookeeper分布式...
    99+
    2024-04-02
  • 基于Zookeeper怎么实现分布式锁
    这篇文章主要介绍“基于Zookeeper怎么实现分布式锁”,在日常操作中,相信很多人在基于Zookeeper怎么实现分布式锁问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”基于Zookeeper怎么实现分布式锁...
    99+
    2023-06-22
  • 如何理解分布式系统下基于Redis的分布式锁
    这篇文章主要介绍“如何理解分布式系统下基于Redis的分布式锁”,在日常操作中,相信很多人在如何理解分布式系统下基于Redis的分布式锁问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大...
    99+
    2024-04-02
  • zookeeper分布式锁如何实现
    这篇文章主要介绍“zookeeper分布式锁如何实现”,在日常操作中,相信很多人在zookeeper分布式锁如何实现问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”zookeeper分布式锁如何实现”的疑惑有所...
    99+
    2023-06-27
  • Zookeeper如何实现分布式锁
    这篇“Zookeeper如何实现分布式锁”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“Zookeeper如何实现分布式锁”文...
    99+
    2023-06-27
  • Java如何实现ZooKeeper分布式锁
    这篇文章主要介绍了Java如何实现ZooKeeper分布式锁,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。什么是分布式锁在我们进行单机应用开发,涉及并发同步的时候,我们往往采...
    99+
    2023-06-29
  • ZooKeeper能否用于分布式锁的实现
    是的,ZooKeeper可以用于分布式锁的实现。ZooKeeper是一个分布式协调服务,可以用来实现分布式系统中的一些共享资源管理问...
    99+
    2024-03-07
    ZooKeeper
  • Zookeeper分布式锁的概念及原理
    文章目录 1.Zookeeper分布式锁的概念 2.分布式锁的实现方式 3.Zookeeper分布式锁的原理 1.Zookeeper分布式锁的概念 分布式锁的概念图如下:一种演变过程。 在...
    99+
    2023-08-22
    分布式 java-zookeeper zookeeper 原力计划
  • InterProcessMutex实现zookeeper分布式锁原理
    原理简介: zookeeper实现分布式锁的原理就是多个节点同时在一个指定的节点下面创建临时会话顺序节点,谁创建的节点序号最小,谁就获得了锁,并且其他节点就会监听序号比自己小的节点,...
    99+
    2024-04-02
  • ZooKeeper中怎么处理分布式锁
    在ZooKeeper中处理分布式锁通常使用临时有序节点来实现。具体步骤如下: 在ZooKeeper的指定节点下创建一个顺序临时节点...
    99+
    2024-04-02
  • ZooKeeper分布式锁的实现方式
    本篇内容介绍了“ZooKeeper分布式锁的实现方式”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!目录一、分布式锁方案比较二、ZooKeep...
    99+
    2023-06-20
  • 分析ZooKeeper分布式锁的实现
    目录一、分布式锁方案比较二、ZooKeeper实现分布式锁2.1、方案一2.2、方案二一、分布式锁方案比较 方案 ...
    99+
    2024-04-02
  • 详解基于redis实现分布式锁
    目录前言原理剖析实现编写注解拦截器拦截上述提及工具问题分析前言 为了保证一个在高并发存场景下只能被同一个线程操作,java并发处理提供ReentrantLock或Synchroniz...
    99+
    2024-04-02
  • Zookeeper的分布式锁的实现方式
    这篇文章主要讲解了“Zookeeper的分布式锁的实现方式”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Zookeeper的分布式锁的实现方式”吧!1. 背景最近在学习 Zookeeper,...
    99+
    2023-06-05
  • 基于Redission的分布式锁实战
    目录一、为什么需要分布式锁二、Redission的实战使用2.1 Redission执行流程2.2 Watch Dog 机制2.3 对比setnx三、代码案例一、为什么需要分布式锁 在系统中,当存在多个进程和线程可以改变...
    99+
    2022-08-14
    Redission分布式锁
  • 基于Redis实现分布式锁
    我们知道分布式锁的特性是排他、避免死锁、高可用。分布式锁的实现可以通过数据库的乐观锁(通过版本号)或者悲观锁(通过for update)、Redis的setnx()命令、Zookeeper(在某个持久节点添加临时有序节点,判断当前节点是否是...
    99+
    2017-09-11
    基于Redis实现分布式锁
  • 分布式事务该如何理解
    这篇文章给大家介绍分布式事务该如何理解,内容非常详细,感兴趣的小伙伴们可以参考借鉴,希望对大家能有所帮助。先上场景:压力测试,同时1万个买家在店铺Shang1购买东西,每个买家账户向shang1账户付钱。    &nbs...
    99+
    2023-06-02
  • 如何操作Redis和zookeeper实现分布式锁
    如何操作Redis和zookeeper实现分布式锁 在分布式场景下,有很多种情况都需要实现最终一致性。在设计远程上下文的领域事件的时候,为了保证最终一致性,在通过领域事件进行通讯的方式中,可以共享存储(领域...
    99+
    2022-06-04
    分布式 操作 Redis
  • 如何分析基于redis分布式锁实现秒杀
    本篇文章为大家展示了如何分析基于redis分布式锁实现秒杀,内容简明扼要并且容易理解,绝对能使你眼前一亮,通过这篇文章的详细介绍希望你能有所收获。业务场景所谓秒杀,从业务角度看,是短时间内多个用户“争抢”资源,这里的资源在大部分秒杀场景里是...
    99+
    2023-06-02
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作