Zookeeper实战-分布式锁的现实

Zookeeper实现分布式锁 如何用Zookeeper实现分布式锁? 在学习分布式锁之前,需要首先了解一下Zookeeper的[临时顺序节点]。 什么是临时顺序节点? 让我们来回顾一下Zookeeper节点的概念: Zookeeper的数据存储结构就像一棵树,这棵树由节点组成,这种节点叫做Znode。 Znode分为四种类型: 1.持久节点 (PERSISTENT) 默认的节点类型。创建节点的客户端与zook... 阅读详情

1. 简介

我们在之前的博文中讲解了如何使用redis实现分布式锁,其实除了 redis 还有 zookeeper 也能实现分布式锁。

废话不多说,直接上图。

从整个流程中可以看出,zk实现分布式锁,主要是靠zk的临时顺序节点和watch机制实现的。

2. quick start

Curator 是 Netflix 公司开源的一套 zookeeper 客户端框架,解决了很多 Zookeeper 客户端非常底层的细节开发工作,包括连接重连、反复注册 Watcher 和 NodeExistsException 异常等。

curator-recipes:封装了一些高级特性,如:Cache 事件监听、选举、分布式锁、分布式计数器、分布式 Barrier 等。

2.1 引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>5.2.0</version>
</dependency>

curator-recipes中已经依赖了zookeeper和curator-framework jar,所以这里不用额外的依赖其他jar。

2.2 测试代码

测试代码其实很简单,只需要几行代码而已,初始化客户端,创建锁对象,加锁 和 释放锁。

这里先把加锁的代码注释掉,试下不加锁的情况。

package com.ldx.zookeeper.controller;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.PostConstruct;

/**
 * 分布式锁demo
 *
 * @author ludangxin
 * @date 2021/9/4
 */
@Slf4j
@RestController
@RequestMapping("lock")
@RequiredArgsConstructor
public class LockDemoController {
   /**
    * 库存数
    */
   private Integer stock = 30;
   /**
    * zk client 
    */
   private static CuratorFramework CLIENT;

   /**
    * 初始化连接信息
    */
   @PostConstruct
   private void init() {
      RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
      CLIENT = CuratorFrameworkFactory.builder().connectString("localhost:2181").retryPolicy(retryPolicy).build();
      CLIENT.start();
   }

   @GetMapping("buy")
   public String buy() {
      // 可重入锁
      InterProcessMutex mutexLock = new InterProcessMutex(CLIENT, "/lock");
      try {
         // 加锁
//         mutexLock.acquire();
         if(this.stock > 0) {
            Thread.sleep(500);
            this.stock--;
         }
         log.info("剩余库存==={}", this.stock);
      } catch(Exception e) {
         log.error(e.getMessage());
         return "no";
      }
      finally {
         try {
            // 释放锁
//            mutexLock.release();
         } catch(Exception e) {
            log.error(e.getMessage());
         }
      }
      return "ok";
   }
}

2.3 启动测试

这里我们使用jemter进行模拟并发请求,当然我们这里只启动了一个server,主要是为了节约文章篇幅(启动多个server还得连接db...),能说明问题即可。

同一时刻发送一百个请求。

测试结果部分日志如下:

很明显出现了超卖了现象,并且请求是无序的(请求是非公平的)。

此时我们将注释的加锁代码打开,再进行测试。

文章福利:现在C++程序员面临的竞争压力越来越大。那么,作为一名C++程序员,怎样努力才能快速成长为一名高级的程序员或者架构师,或者说一名优秀的高级工程师或架构师应该有怎样的技术知识体系,这不仅是一个刚刚踏入职场的初级程序员,也是工作三五年之后开始迷茫的老程序员,都必须要面对和想明白的问题。为了帮助大家少走弯路,技术要做到知其然还要知其所以然。以下视频获取点击:C++架构师学习资料

如果想学习C++工程化、高性能及分布式、深入浅出。性能调优、TCP,协程,Nginx源码分析Nginx,ZeroMQ,MySQL,Redis,MongoDB,ZK,Linux内核,P2P,K8S,Docker,TCP/IP,协程,DPDK的朋友可以看一下这个学习地址:C/C++Linux服务器开发高级架构师/Linux后台架构师icon-default.png?t=L892https://ke.qq.com/course/417774?flowToken=1013189

测试结果部分日志如下:

很明显没有出现超卖的现象。

通过zk 客户端工具查看创建的部分临时节点如下:

3. 源码解析

3.1 加锁逻辑

我们再通过查看Curator加锁源码来验证下我们的加锁逻辑。

首先我们查看InterProcessMutex::acquire()方法,并且我们通过注释可以得知该方法加的锁是可重入锁。

/**
 * Acquire the mutex - blocking until it's available. Note: the same thread
 * can call acquire re-entrantly. Each call to acquire must be balanced by a call
 * to {@link #release()}
 *
 * @throws Exception ZK errors, connection interruptions
 */
@Override
public void acquire() throws Exception
{
    if ( !internalLock(-1, null) )
    {
        throw new IOException("Lost connection while trying to acquire lock: " + basePath);
    }
}

查看internalLock方法如下。

private final ConcurrentMap<Thread, LockData> threadData = Maps.newConcurrentMap();

private boolean internalLock(long time, TimeUnit unit) throws Exception {
    // 获取当前线程
    Thread currentThread = Thread.currentThread();
    // 在map中查看当前线程有没有请求过
    LockData lockData = threadData.get(currentThread);
    if ( lockData != null) {
        // 请求过 则 +1 , 实现了锁的重入逻辑
        lockData.lockCount.incrementAndGet();
        return true;
    }
    // 尝试获取锁
    String lockPath = internals.attemptLock(time, unit, getLockNodeBytes());
    if ( lockPath != null) {
        // 创建锁对象
        LockData newLockData = new LockData(currentThread, lockPath);
        // 添加到map中
        threadData.put(currentThread, newLockData);
        return true;
    }

    return false;
}

我们继续查看LockInternals::attemptLock()尝试获取锁逻辑如下。

String attemptLock(long time, TimeUnit unit, byte[] lockNodeBytes) throws Exception {
    final long      startMillis = System.currentTimeMillis();
    final Long      millisToWait = (unit != null) ? unit.toMillis(time) : null;
    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 {
            // 创建锁
            ourPath = driver.createsTheLock(client, path, localLockNodeBytes);
            // 判断是否加锁成功
            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;
}

在这里先查看下创建锁的逻辑StandardLockInternalsDriver::createsTheLock(),如下。

@Override
public String createsTheLock(CuratorFramework client, String path, byte[] lockNodeBytes) throws Exception {
    String ourPath;
    // 判断有没有传znode data 我们这里为null
    if(lockNodeBytes != null) {
        ourPath = client.create().creatingParentContainersIfNeeded().withProtection().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path, lockNodeBytes);
    } else {
      // 创建Container父节点且创建临时的顺序节点
        ourPath = client.create().creatingParentContainersIfNeeded().withProtection().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path);
    }
    return ourPath;
}

锁创建成功后我们再查看下程序是如何加锁的LockInternals::internalLockLoop()。

private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception {
    boolean     haveTheLock = false;
    boolean     doDelete = false;
    try {
        if(revocable.get() != null) {
            client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
        }
	// 当客户端初始化好后 且 还没有获取到锁
        while((client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock) {
            // 获取所有的子节点 且 递增排序
            List<String>        children = getSortedChildren();
            // 获取当前节点 path
            String              sequenceNodeName = ourPath.substring(basePath.length() + 1);
	    // 获取当前锁
            // 1. 先判断当前节点是不是下标为0的节点,即是不是序列值最小的节点。
            // 2. 如果是则获取锁成功,返回成功标识。
            // 3. 如果不是则返回比它小的元素作为被监听的节点
            PredicateResults    predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
            if(predicateResults.getsTheLock()) {
                // 获取锁成功 返回成功标识
                haveTheLock = true;
            } else {
                // 索取锁失败,则获取比它小的上一个节点元素
                String  previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();

                synchronized(this) {
                    try {
                        // 监听比它小的上一个节点元素
                        client.getData().usingWatcher(watcher).forPath(previousSequencePath);
                        // 如果设置了超时,则继续判断是否超时
                        if(millisToWait != null) {
                            millisToWait -= (System.currentTimeMillis() - startMillis);
                            startMillis = System.currentTimeMillis();
                            if(millisToWait <= 0) {
                                doDelete = true;    
                                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 {
        // 报错即删除该节点
        if(doDelete) {
            deleteOurPath(ourPath);
        }
    }
    return haveTheLock;
}

最后 我们再看下上段代码中提到的很关键的方法driver.getsTheLock() 即 StandardLockInternalsDriver::getsTheLock()。

@Override
public PredicateResults getsTheLock(CuratorFramework client, List<String> children, String sequenceNodeName, int maxLeases) throws Exception {
    // 获取当前节点的下标 
    int             ourIndex = children.indexOf(sequenceNodeName);
    validateOurIndex(sequenceNodeName, ourIndex);
    // 这里的maxLeases == 1,即当前节点的下标是不是0
    boolean         getsTheLock = ourIndex < maxLeases;
    // 如果当前节点的下标为0,则不返回被监听的节点(因为自己已经是最小的节点了),如果不是则返回比自己小的节点作为被监听的节点。
    String          pathToWatch = getsTheLock ? null : children.get(ourIndex - maxLeases);
    // 构造返回结果
    return new PredicateResults(pathToWatch, getsTheLock);
}

3.2 小节

其实加锁的源码还是比较清晰和易懂的,我们在这里再总结下。

  1. 执行InterProcessMutex::acquire()加锁方法。
  2. InterProcessMutex::internalLock()判断当前线程是加过锁,如果加过则加锁次数+1实现锁的重入,如果没有加过锁,则调用LockInternals::attemptLock()尝试获取锁。
  3. LockInternals::attemptLock()首先创建Container父节点再创建临时的顺序节点,然后执行加锁方法LockInternals::internalLockLoop()。
  4. LockInternals::internalLockLoop()先获取当前Container下的所有顺序子节点并且按照从小到大排序。调用StandardLockInternalsDriver::getsTheLock()方法加锁,先判断当前节点是不是最小的顺序节点,如果是则加锁成功,如果不是则返回上一个比他小的节点,作为被监听的节点。上一步加锁成功则返回true,如果失败则执行监听逻辑。

3.3 释放锁逻辑

@Override
public void release() throws Exception {
    /*
        Note on concurrency: a given lockData instance
        can be only acted on by a single thread so locking isn't necessary
     */
    // 获取当前线程
    Thread currentThread = Thread.currentThread();
    // 查看当前线程有没有锁
    LockData lockData = threadData.get(currentThread);
    if(lockData == null) {
        // 没有锁 还释放,报错
        throw new IllegalMonitorStateException("You do not own the lock: " + basePath);
    }
    // 有锁则 锁次数 -1
    int newLockCount = lockData.lockCount.decrementAndGet();
    // 如果锁的次数还大于0,说明还不能释放锁,因为重入的方法还未执行完
    if (newLockCount > 0) {
        return;
    }
    if (newLockCount < 0) {
        // 锁的次数小于0,报错
        throw new IllegalMonitorStateException("Lock count has gone negative for lock: " + basePath);
    }
    try {
        // 删除节点
        internals.releaseLock(lockData.lockPath);
    }
    finally {
        // 从当前的map中移除
        threadData.remove(currentThread);
    }
}

final void releaseLock(String lockPath) throws Exception{
    client.removeWatchers();
    revocable.set(null);
    deleteOurPath(lockPath);
}

4. redis 和 zookeeper

Zookeeper采用临时节点和事件监听机制可以实现分布式锁,Redis主要是通过setnx命令实现分布式锁。
Redis需要不断的去尝试获取锁,比较消耗性能,Zookeeper是可以通过对锁的监听,自动获取到锁,所以性能开销较小。
另外如果获取锁的jvm出现bug或者挂了,那么只能redis过期删除key或者超时删除key,Zookeeper则不存在这种情况,连接断开节点则会自动删除,这样会即时释放锁。

这样一听感觉zk的优势还是很大的。

但是要考虑一个情况在锁并发不高的情况下 zk没有问题 如果在并发很高的情况下 zk的数据同步 可能造成锁时延较长,在选举过程中需要接受一段时间zk不可用(因为ZK 是 CP 而 redis集群是AP)。

所以说没有哪个技术是适用于任何场景的,具体用哪个技术,还是要结合当前的技术架构和业务场景做选型和取舍。

springboot基于zookeeper实现分布式锁 参考链接: https://blog.youkuaiyun.com/wuzhiwei549/article/details/80692278 https://blog.52itstyle.vip/archives/3202/ 先说明一下zookeeper实现分布式锁的原理,这里参看csdn一篇非常好的文章,如果不想看原理直接跳过看后面的具体代码实现 单机应用架构中,秒杀案例使用ReentrantLcok或者s... 阅读详情

相关推荐

基于ZooKeeper的分布式锁实现(C++版本)

一、简介分布式同步是Zookeeper的功能之一,但Zookeeper的分布式同步(分布式锁)功能并非以直接的接口呈现的。开发者需要额外地基于Zookeeper的节点(node)的分布式同步特性来实现分布式锁的接口。本文将提供基于基于ZooKeeper的分布式锁的C++接口及实现,实现中用到了部分C++11特性。另外,本实现使用的是经过封装的ZooKeeper接口,本文只列出这些ZooKeeper...

warden007的博客 3773

Zookeeper分布式锁实现

Zookeeper就是使用临时顺序节点特性实现分布式锁的,。

m0_62943934的博客 2196

通达信K线主图指标公式实战:如何用颜色标记快速识别涨停与炸板信号

本文详细介绍了如何利用通达信K线主图指标公式,通过颜色标记快速识别涨停与炸板等关键信号。通过实战拆解公式源码,手把手教您构建直观的“视觉交易系统”,将复杂的K线形态转化为醒目的颜色信号,帮助投资者高效聚焦机会与风险,提升技术分析效率。

weixin_29302047的博客 1790

ZK(ZooKeeper)分布式锁实现,史上超级详细

作为过来人,小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料,针对上面一套系统大纲小编也有对应的相关进阶架构视频资料25881)][外链图片转存中…(img-V9m0bH3J-1711985225882)][外链图片转存中…(img-41bDzCZN-1711985225882)]既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!

2301_76190858的博客 1077

全志平台9365芯片MIPI屏点亮难题:从时序异常到寄存器修复

本文深入剖析了在全志平台驱动9365芯片MIPI显示屏时,屏幕不亮的典型问题。核心原因在于全志平台DSI时钟计算与9365芯片要求的240MHz频率不匹配。文章提供了通过配置关键寄存器0x37来修复时序异常的具体方案,并分享了调试技巧与设备树参数调整方法,帮助开发者在不牺牲屏幕刷新率性能的前提下成功点亮屏幕。

mqtt6iot的博客 572

logisim实验——通过2个半加器实现1-bit全加器,通过4个一位全加器构成4-bit加法器(详解)

一、由异或门和与门所构成的半加器: 二、由两个半加器构成的1-bit全加器: ..

zep 1万+

开源客户端Curator 使用(下)

一 新建curatorupdatedata 1 代码 package com.cakin.zookerper; import org.apache.curator.RetryPolicy; import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.CuratorFramew

实践求真知 481

合宙Air780EP速连OneNET:AT+MQTT应用指南

本文详细讲解了合宙Air780EP使用AT指令通过MQTT接入OneNET的过程。

2401_82812461的博客 1392

ClassNotFoundException: org.apache.curator.framework.recipes.cache.TreeCacheListener

并没有找到合适的解决方法, 用中文搜索锁不到,重新加maven依赖也不好使,用英文搜索在github上说是版本的问题,说2.6.0版本不行,我把curator-recipes和curator-framework的版本由2.12换成2.8.0解决,

weixin_44451520的博客 1879

Typora绘制思维导图

我们观察一下,其实思维导图就是树状结构的数据嘛,作为程序员,拿语言写树状结构的数据是很平常的事情。而且写代码可比画图省事多了,查阅资料可以知道,有一种`mermaid`语法,就是做这件事情的,支持 UML,甘特图,流程图等。

Peter Cheung的博客 7934

基于Abaqus的横向各向同性线弹性理想塑性材料模型的umat子程序实现——以Fortran为例,带您揭秘弹性塑性模型编程之道

通过以上步骤,我们已经在Abaqus中使用Fortran实现了横向各向同性线弹性理想塑性材料模型的umat子程序。在实际应用中,我们需要根据具体的材料特性和加载条件来调整模型参数和计算过程。尽管我在这篇文章中尽力提供了详细的教程,但由于我自身的知识限制和经验不足,可能会有误解或错误。我希望大家在学习过程中能多思考,多实践,多交流,以更好地理解和掌握这个主题。

qq_38334677的博客 1691

zookeeper详解

概念: zookeeper是apache hadoop项目下的一个子项目,是一个树形目录服务,是一个开源的分布式的应用程序协调服务 主要功能: 一、配置管理 二、分布式锁 三、集群管理 数据模型: zookeeper是一个树形的目录结构,其数据模型和linux的文件系统目录树很类似,拥有一个层次结构,每个节点被称为znode,每个节点上都会保存自己的数据和节点信息,节点可以拥有自己的子节点,同时也允许少量的数据(1m)存储在该节点下。 节点可以分为四大类: PERSISTENT 持久化节点

火烧云的博客 372

AgentScope Java 2.0 项目实战: 从零构建自己的个人AI助手“小龙虾“

本文系统介绍如何基于Spring Boot WebFlux、React 18和TypeScript,从零搭建一个本地化的个人AI助手管理平台——AgentScope Paw。项目支持多Agent创建与管理、SSE流式对话、工作区文件CRUD、技能市场、子智能体孵化、AI辅助起草Agent配置等核心功能,并深度集成钉钉、企业微信、飞书、GitHub等IM通道。

program哲学 1436

zookeeper应用实战之分布式锁

1. 什么是分布式锁? 我们先来看这样一个场景,如下图所示,两个用户同时去抢购秒杀商品,当秒杀服务同时收到秒杀请求时,都去进行库存扣减,此时在没有做任何处理的情况下,就会导致库存数量变成负数从而导致超卖现象。 这种情况下如果是单体项目,我们一般会选择加锁的方式来避免并发的问题。但是在分布式场景中,采用传统的锁并不能解决跨进程并发的问题,所以需要引入一个分布式锁,来解决多个节点之间的访问控制。 2. Zookeeper如何实现分布式锁 实现分布式的方式有很多种,本文主要讲述如何使用zookeeper实现分布

Java是世界上最好的语言 9408

华为OD机考双机位C卷 - 信道分配(Java & Python& JS & C/C++ & GO )

华为OD机考双机位C卷 - 信道分配

算法大师! 455

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Zookeeper实战——分布式锁实现以及原理

文章目录Zookeeper 分布式锁实现原理具体流程代码实现客户端创建工厂类创建 Lock 锁接口Lock 实现类(ZkLock)自定义 ZK 分布式锁测试独占锁 & 共享锁Curator 实现分布式锁ZooKeeper 分布式锁的优缺点 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。分布式锁的实现方式有很多种,比如 Redis 、数据库 、zookeeper 等。这篇文章主要介绍用 Zookeeper 实现分布式锁。 Zookeeper 分布式锁实现原理 先说结论:Zookeeper.

KIMTOU的博客 1万+

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

实战:ZooKeeper实现分布式锁

假定,取水时以家庭为单位,家庭的某人拿到号,其他的家庭成员过来打水,这时候不用再取号,如图10-4所示。图10-4 同一家庭的人不需要重复排队图10-4中,排在1号的家庭,老公取号,假设其老婆来了,直接排第一个,正所谓妻凭夫贵。再看上图的2号,父亲正在打水,假设其儿子和女儿也到井边了,直接排第二个,所谓子凭父贵。总之,如果取水时以家庭为单位,则同一个家庭,可以直接复用排号,不用从后面排起重新取号。以上这个故事模型中,取号一次,可以用来多次取水,其原理为可重入锁的模型。

为无为,事无事,味无味。 1691

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

Zookeeper分布式锁

多个线程去create一个path的时候,只有一个线程可以create成功,也就相当于抢到了锁,其他线程只能不停的尝试create,而抢到锁的线程A,在执行完后释放锁,即delete path,就会有下一个线程create成功。为了避免出现,抢到锁后客户端宕机,导致锁无法释放,即拿锁线程不会delete path,create的节点设置为临时节点,这样当客户端宕机时,节点也跟着自动销毁,也就解锁了。即:只监听想监听到的状态。zk: 临时节点序列化,监听上一个小的节点,实现排队阻塞,实现公平锁。

范大的博客 2280

Zookeeper分布式锁实战

在单体的应用开发场景中涉及并发同步的时候,大家往往采用Synchronized(同步)或者其他同一个JVM内Lock机制来解决多线程间的同步问题。在分布式集群工作的开发场景中,就需要一种更加高级的锁机制来处理跨机器的进程之间的数据同步问题,这种跨机器的锁就是分布式锁。目前分布式锁,比较成熟、主流的方案:1. 基于数据库的分布式锁。这种方案使用数据库的事务和锁机制来实现分布式锁。虽然在某些场景下可以实现简单的分布式锁,但由于数据库操作的性能相对较低,并且可能面临锁表的风险,所以一般不是首选方案。

尽力而为! 1101

ZooKeeper实现分布式锁

一、Zookeeper实现分布式锁思路 1.1.分布式锁应具备哪些条件 分布式锁应该具备以下条件: 在分布式环境下,在一个时间点,最多被一个请求方持有 高可用、高性能的获取和释放 具备可重入性 具备失效机制,防止死锁 具备非阻塞特性,即没有获取到锁将直接返回失败 1.2.ZooKeeper实现分布式锁所具备的特性 1.2.1.高可用、高性能 ZooKeeper的数据是内存读取的,本身就具备高性能特性 ZooKeeper具备很好的故障恢复能力 在集群模式下,当Leader节点宕机后,当前集群会选出新的

qq_28136919的博客 4820

分布式锁用 Redis 还是 Zookeeper

什么是分布式锁 在分布式架构中,Java的锁无法管理多个实例,因此需要有一个类似于统一管理锁的架构模式,即分布式锁。 目前比较常见的分布式锁实现方案有以下几种: 基于数据库乐观锁,如MySQL(增加字段版本标识version控制实现) 基于缓存,如Redis 基于Zookeeper、etcd等(ZooKeeper机制规定:同一个目录下只能有一个唯一的文件名,借助ZooKeeper的临时节点实现) 例如两个订单服务,对要更新数据库的数据,如果能获取到相应的锁才能进行后续操作。 分布式锁的几种实现方式 基

一条小黑龙的博客 4155

分布式锁原理与实战四:ZooKeeper分布式锁Java代码实现

如果自己没有获得锁,则要监听前一个节点,此时需要找出前一个节点的路径,并保存在 prior_path 成员中,供后面的 await()等待方法去监听使用。这里,仅仅去监听自己前一个节点的变动,而不是其他节点的变动,提升效率。一旦队列中的后面的节点,获得前一个子节点变更通知,则开始进行判断,判断自己是否为当前子节点列表中序号最小的子节点,如果是,则认为加锁成功;因为,在获取的远程子节点列表中的其他路径返回结果时,返回的都是短路径,都只有最后一层路径。(2)判断是否是第一个,如果是第一个,则加锁成功。

z13197919100的博客 1881

zookeeper - 实现分布式锁

zookeeper - 实现分布式锁

qq_43350524的博客 1404

Zookeeper实现分布式锁实战应用

在分布式系统中,当多个进程或服务需要互斥地访问共享资源时,就需要分布式锁来协调。Zookeeper因其强一致性和临时节点特性,非常适合实现分布式锁。

bsklhao的博客 785
上一篇: 深入理解掌握零拷贝技术
下一篇: DPDK分析学习之全网唯一的DPDK教学课程丨虚拟化高性能专家之路
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值