分布式锁基于zookeeper实现

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

发布一个k8s部署视频:https://edu.youkuaiyun.com/course/detail/26967

课程内容:各种k8s部署方式。包括minikube部署,kubeadm部署,kubeasz部署,rancher部署,k3s部署。包括开发测试环境部署k8s,和生产环境部署k8s。

腾讯课堂连接地址https://ke.qq.com/course/478827?taid=4373109931462251&tuin=ba64518

第二个视频发布  https://edu.youkuaiyun.com/course/detail/27109

腾讯课堂连接地址https://ke.qq.com/course/484107?tuin=ba64518

介绍主要的k8s资源的使用配置和命令。包括configmap,pod,service,replicaset,namespace,deployment,daemonset,ingress,pv,pvc,sc,role,rolebinding,clusterrole,clusterrolebinding,secret,serviceaccount,statefulset,job,cronjob,podDisruptionbudget,podSecurityPolicy,networkPolicy,resourceQuota,limitrange,endpoint,event,conponentstatus,node,apiservice,controllerRevision等。

第三个视频发布:https://edu.youkuaiyun.com/course/detail/27574

详细介绍helm命令,学习helm chart语法,编写helm chart。深入分析各项目源码,学习编写helm插件
————————————————------------------------------------------------------------------------------------------------------------------

 

public class LockUtil {
    private static final Logger logger = LoggerFactory.getLogger(LockUtil.class);
    private static final byte[]  data      = { 0x12, 0x34 };
    private static Watcher watcher =  new Watcher() {  
        
        public void process(WatchedEvent event) {  
            LoggerUtils.logInfo(logger,"process : " + event.getType());  
        }  
    }; 
    private static ZooKeeper           zookeeper=null;
    private final String         root;                                     //根节点路径
    private String               id;
    private LockNode             idName;
    private String               ownerId;
    private String               lastChildId;
    private Throwable            other     = null;
    private KeeperException      exception = null;
    private InterruptedException interrupt = null;
    private static final Long DEFAULT_TIMEOUT_PERIOD=1000L;
    private ReentrantLock       reentrantLock = new ReentrantLock();

    static{
        try
        {
            zookeeper =new ZooKeeper("ip:port", DEFAULT_TIMEOUT_PERIOD.intValue(),watcher);
        }
        catch (IOException e)
        {
            logger.error("获取zookeeper错误");
        }
    }
     
    public LockUtil(String root) {
        this.root = root;
        ensureExists(root);
       
    }
    

    /**
     * 尝试获取锁操作,阻塞式可被中断
     * @throws NestableRuntimeException 
     */
    public void lock() throws InterruptedException, KeeperException, NestableRuntimeException {
        // 可能初始化的时候就失败了
        if (exception != null) {
            throw exception;
        }

        if (interrupt != null) {
            throw interrupt;
        }

        if (other != null) {
            throw new NestableRuntimeException(other);
        }

        if (isOwner()) {//锁重入
            return;
        }
        reentrantLock.lock();
        BooleanMutex mutex = new BooleanMutex();
        acquireLock(mutex);
        // 避免zookeeper重启后导致watcher丢失,会出现死锁使用了超时进行重试
        try {
            mutex.get(DEFAULT_TIMEOUT_PERIOD, TimeUnit.MICROSECONDS);// 阻塞等待值为true
            // mutex.get();
        } catch (TimeoutException e) {
            if (!mutex.state()) {
                lock();
            }
        }

        if (exception != null) {
            throw exception;
        }

        if (interrupt != null) {
            throw interrupt;
        }

        if (other != null) {
            throw new NestableRuntimeException(other);
        }
    }

    /**
     * 尝试获取锁对象, 不会阻塞
     * 
     * @throws InterruptedException
     * @throws KeeperException
     * @throws NestableRuntimeException 
     */
    public boolean tryLock() throws KeeperException, NestableRuntimeException {
        // 可能初始化的时候就失败了
        if (exception != null) {
            throw exception;
        }

        if (isOwner()) {//锁重入
            return true;
        }
        reentrantLock.lock();
        acquireLock(null);

        if (exception != null) {
            throw exception;
        }

        if (interrupt != null) {
            Thread.currentThread().interrupt();
        }

        if (other != null) {
            throw new NestableRuntimeException(other);
        }

        return isOwner();
    }

    /**
     * 释放锁对象
     */
    public void unlock() throws KeeperException {
        if (id != null) {
            try {
                zookeeper.delete(root + "/" + id, -1);
                reentrantLock.unlock();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (KeeperException.NoNodeException e) {
                // do nothing
            } finally {
                id = null;
            }
        } else {
            //do nothing
        }
    }

    private void ensureExists(final String path) {
        try {
            Stat stat = zookeeper.exists(path, false);
            if (stat != null) {
                return;
            }

            zookeeper.create(path, data,Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } catch (KeeperException e) {
            exception = e;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            interrupt = e;
        }
    }

    /**
     * 返回锁对象对应的path
     */
    public String getRoot() {
        return root;
    }

    /**
     * 判断当前是不是锁的owner
     */
    public boolean isOwner() {
        return id != null && ownerId != null && id.equals(ownerId);
    }

    /**
     * 返回当前的节点id
     */
    public String getId() {
        return this.id;
    }

    // ===================== helper method =============================

    /**
     * 执行lock操作,允许传递watch变量控制是否需要阻塞lock操作
     */
    private Boolean acquireLock(final BooleanMutex mutex) {
        try {
            do {
                if (id == null) {//构建当前lock的唯一标识
                    long sessionId = zookeeper.getSessionId();
                    String prefix = "x-" + sessionId + "-";
                    //如果第一次,则创建一个节点
                    String path = zookeeper.create(root + "/" + prefix, data,
                            Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                    int index = path.lastIndexOf("/");
                    id = StringUtils.substring(path, index + 1);
                    idName = new LockNode(id);
                }

                if (id != null) {
                    List<String> names = zookeeper.getChildren(root, false);
                    if (names.isEmpty()) {
                        id = null;//异常情况,重新创建一个
                    } else {
                        //对节点进行排序
                        SortedSet<LockNode> sortedNames = new TreeSet<LockNode>();
                        for (String name : names) {
                            sortedNames.add(new LockNode(name));
                        }

                        if (sortedNames.contains(idName) == false) {
                            id = null;//清空为null,重新创建一个
                            continue;
                        }

                        //将第一个节点做为ownerId
                        ownerId = sortedNames.first().getName();
                        if (mutex != null && isOwner()) {
                            mutex.set(true);//直接更新状态,返回
                            return true;
                        } else if (mutex == null) {
                            return isOwner();
                        }

                        SortedSet<LockNode> lessThanMe = sortedNames.headSet(idName);
                        if (!lessThanMe.isEmpty()) {
                            //关注一下排队在自己之前的最近的一个节点
                            LockNode lastChildName = lessThanMe.last();
                            lastChildId = lastChildName.getName();
                            //异步watcher处理
                            Stat stat=zookeeper.exists(root + "/" + lastChildId, new AsyncWatcher() {

                                public void asyncProcess(WatchedEvent event) {
                                    acquireLock(mutex);
                                }

                            });

                            if (stat == null) {
                                acquireLock(mutex);// 如果节点不存在,需要自己重新触发一下,watcher不会被挂上去
                            }
                        } else {
                            if (isOwner()) {
                                mutex.set(true);
                            } else {
                                id = null;// 可能自己的节点已超时挂了,所以id和ownerId不相同
                            }
                        }
                    }
                }
            } while (id == null);
        } catch (KeeperException e) {
            exception = e;
            if (mutex != null) {
                mutex.set(true);
            }
        } catch (InterruptedException e) {
            interrupt = e;
            if (mutex != null) {
                mutex.set(true);
            }
        } catch (Throwable e) {
            other = e;
            if (mutex != null) {
                mutex.set(true);
            }
        }

        if (isOwner() && mutex != null) {
            mutex.set(true);
        }
        return Boolean.FALSE;
    }
public class LockNode implements Comparable<LockNode>
{
    private final String name;

    private String       prefix;

    private int          sequence = -1;

    public LockNode(String name)
    {
        this.name = name;
        this.prefix = name;
        int idx = name.lastIndexOf('-');
        if (idx >= 0)
        {
            this.prefix = name.substring(0, idx);
            try
            {
                this.sequence = Integer.parseInt(name.substring(idx + 1));
            }
            catch (Exception e)
            {
                // ignore
            }
        }
    }

    public int compareTo(LockNode that)
    {
        int s1 = this.sequence;
        int s2 = that.sequence;
        if (s1 == -1 && s2 == -1)
        {
            return this.name.compareTo(that.name);
        }
        if (s1 == -1)
        {
            return -1;
        }
        else if (s2 == -1)
        {
            return 1;
        }
        else
        {
            return s1 - s2;
        }
    }

    public String getName()
    {
        return name;
    }

    public int getSequence()
    {
        return sequence;
    }

    public String getPrefix()
    {
        return prefix;
    }

    public String toString()
    {
        return name.toString();
    }

    // ==================== hashcode & equals方法=======================
    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        LockNode other = (LockNode) obj;
        if (name == null)
        {
            if (other.name != null)
            {
                return false;
            }
        }
        else if (!name.equals(other.name))
        {
            return false;
        }
        return true;
    }
}

 

public class BooleanMutex {

    private Sync sync;

    public BooleanMutex() {
        sync = new Sync();
        set(false);
    }

    public BooleanMutex(Boolean mutex) {
        sync = new Sync();
        set(mutex);
    }

    /**
     * 阻塞等待Boolean为true
     * 
     * @throws InterruptedException
     */
    public void get() throws InterruptedException {
        sync.innerGet();
    }

    /**
     * 阻塞等待Boolean为true,允许设置超时时间
     * 
     * @param timeout
     * @param unit
     * @throws InterruptedException
     * @throws TimeoutException
     */
    public void get(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
        sync.innerGet(unit.toNanos(timeout));
    }

    /**
     * 重新设置对应的Boolean mutex
     * 
     * @param mutex
     */
    public void set(Boolean mutex) {
        if (mutex) {
            sync.innerSetTrue();
        } else {
            sync.innerSetFalse();
        }
    }

    public boolean state() {
        return sync.innerState();
    }

    /**
     * Synchronization control for BooleanMutex. Uses AQS sync state to
     * represent run status
     */
    private final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -7828117401763700385L;

        /** State value representing that TRUE */
        private static final int  TRUE             = 1;
        /** State value representing that FALSE */
        private static final int  FALSE            = 2;

        private boolean isTrue(int state) {
            return (state & TRUE) != 0;
        }

        /**
         * 实现AQS的接口,获取共享锁的判断
         */
        protected int tryAcquireShared(int state) {
            // 如果为true,直接允许获取锁对象
            // 如果为false,进入阻塞队列,等待被唤醒
            return isTrue(getState()) ? 1 : -1;
        }

        /**
         * 实现AQS的接口,释放共享锁的判断
         */
        protected boolean tryReleaseShared(int ignore) {
            //始终返回true,代表可以release
            return true;
        }

        boolean innerState() {
            return isTrue(getState());
        }

        void innerGet() throws InterruptedException {
            acquireSharedInterruptibly(0);
        }

        void innerGet(long nanosTimeout) throws InterruptedException, TimeoutException {
            if (!tryAcquireSharedNanos(0, nanosTimeout))
                throw new TimeoutException();
        }

        void innerSetTrue() {
            for (;;) {
                int s = getState();
                if (s == TRUE) {
                    return; //直接退出
                }
                if (compareAndSetState(s, TRUE)) {// cas更新状态,避免并发更新true操作
                    releaseShared(0);//释放一下锁对象,唤醒一下阻塞的Thread
                }
            }
        }

        void innerSetFalse() {
            for (;;) {
                int s = getState();
                if (s == FALSE) {
                    return; //直接退出
                }
                if (compareAndSetState(s, FALSE)) {//cas更新状态,避免并发更新false操作
                    setState(FALSE);
                }
            }
        }

    }
}
public abstract class AsyncWatcher implements Watcher
{
    private static final int       DEFAULT_POOL_SIZE    = 30;

    private static final int       DEFAULT_ACCEPT_COUNT = 60;

    private static ExecutorService executor             = new ThreadPoolExecutor(
                                                                1,
                                                                DEFAULT_POOL_SIZE,
                                                                0L,
                                                                TimeUnit.MILLISECONDS,
                                                                new ArrayBlockingQueue(
                                                                        DEFAULT_ACCEPT_COUNT),
                                                                new NamedThreadFactory(
                                                                        "Arbitrate-Async-Watcher"),
                                                                new ThreadPoolExecutor.CallerRunsPolicy());

    public void process(final WatchedEvent event)
    {
        executor.execute(new Runnable()
        {// 提交异步处理
            @Override
            public void run()
            {
                asyncProcess(event);
            }
        });
    }

    public abstract void asyncProcess(WatchedEvent event);
}

 

public class NestableRuntimeException extends Exception
{
    public NestableRuntimeException(Throwable nest){
        super(nest);
    }
}



 

基于zookeeper实现分布式锁 前言:2016春节之后一直比较忙,因此博客N个没有更新,现在也是忙里偷闲,偷偷的更新一篇! 一、分布式锁介绍         分布式锁主要用于在分布式环境中保护跨进程、跨主机、跨网络的共享资源实现互斥访问,以达到保证数据的一致性。 二、架构介绍         在介绍使用Zookeeper实现分布式锁之前,首先看当前的系统架构图 阅读详情

相关推荐

springboot基于zookeeper实现分布式锁

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

holmes369的博客 3453

Kubernetes搭建Zookeeper和Kafka集群

Kafka 提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加 例如:第一章 Python 机器学习入门之pandas的使用 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么? 二、使用步骤 1.引入库 2.读入数据 总结 前言 Kubernetes搭建Zookeeper和Kafka集群 一、搭建Zookeeper集群 1.创建集群Service的zookeeper-svc.ya

Daniel462038751的专栏 1493

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

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

warden007的博客 3772

基于AQS实现互斥信号(BooleanMutex)

背景   最近一个月都在做项目,我主要负责分布式任务的调度的功能,需要实现一个分布式的授权控制。   具体的需求:   1.  首先管理员启动整个任务,并设置执行权限   2.  工作节点收到消息后就会创建对应的线程,并开始执行任务(任务都是由一个管理员进行分配)   3.  运行过程中管理员需要临时中断某个任务,需要设置一个互斥信号,此时对应的工作节点都需要被阻塞,注意不是完全销毁 ...

agapple 335

机器人学习-matlab四足机器人控制仿真

《机器人学,机器视觉与控制》学习笔记 使用工具箱版本9.10 题目与解决思路: 【1】. 通过减少复位期间的抬腿高度来缩短复位的轨迹 Z轴向下,为了减小复位器件的抬腿高度,应当缩小△Z,故可以将示例程序中zu值调大。 【2】. 增加腿的步幅 腿的步幅可由改变x方向上腿前进和后退运动的极限来达到,令xf = 7; xb = -xf;即可。 ...

weixin_44609769的博客 5541

nRF52811墨水屏时钟DIY:从全刷到局刷的实战改造指南(附完整代码)

本文详细介绍了如何将基于nRF52811的墨水屏时钟从耗电的全屏刷新模式改造为高效的局部刷新模式。通过剖析全刷与局刷的原理差异,提供了从工程架构、驱动层适配到应用层逻辑重构的完整实战指南,并附上关键代码示例。改造后,设备功耗显著降低,续航大幅提升,同时解决了视觉闪烁问题,是DIY低功耗墨水屏应用的实用参考。

weixin_29194693的博客 356

【Zookeeper系列四】ZooKeeper 分布式锁实现

为什么80%的码农都做不了架构师?>>> ...

weixin_34032621的博客 252

Python+Vue计算机毕业设计风电场监控系统的设计与实现7bd6i(程序+LW+源码+部署)

Python3.7.7+Django+Mysql5.7+pip list+HBuilderX(Vscode也行)+Vue+Pychram社区版。2. 前端:vue+css+javascript+jQuery+easyUI+highcharts。2.IDE环境:Python和Python 社区版都可以。Django + Vue +Python+Mysql 等等组成,B/S模式等等。该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。1. 后端:Python、Vue、Django、Mysql。

华信计算机毕设源码程序 344

关于Mutex的构造函数参数设置

Mutex的英文解释就是互斥体,也就是线程或者进程在同时访问一个资源的时候,是需要排他访问,也就是说一个时间段内只能有一个线程对象访问公共资源。 Mutex的构造函数分为Mutex(),Mutex(Boolean),Mutex(boolean, string)。 下面就较这3个构造函数分别进行比较分析。 1、  Mutex()这样一个构造函数相当于执行了Mutex(false),这样一个构造

阿达King哥的博客 4416

STM32H5 USB虚拟串口:用Classic驱动移植CDC实践

USB虚拟串口(CDC)是嵌入式系统最常用的主机通信方式之一,本质是借助USB协议模拟串口收发,无需额外驱动即可在PC上生成COM口。其实现依赖USB设备协议栈完成枚举、控制传输与批量传输。传统USBD Classic库不依赖RTOS,代码轻量、调用链短,非常适合裸机或轻量状态机架构;而USBX功能强大但需要ThreadX内核,资源开销较大。在电机控制器、传感器采集等场景中,日志输出与参数配置仅需简单的双向数据通道,Classic驱动往往更务实。本文基于STM32H5平台,详细梳理了使用Classic驱动移

weixin_29178069的博客 336

基于Arduino的智能光源调节系统设计

本文设计了一个基于Arduino的智能光源调节系统,通过光敏传感器检测环境光照强度并自动调节光源亮度,同时提供了手动控制和远程控制功能。系统采用Wi-Fi模块实现远程控制,用户可以通过手机或网页进行操作。未来,随着智能家居技术的进一步发展,系统可以加入更多智能化的功能,如语音控制、自动场景切换等,为用户提供更便捷的使用体验。同时,随着5G、物联网技术的普及,系统的远程控制能力将更加完善,能够实现更加精准的控制和更高效的数据传输。

2201_76125393的博客 753

AQS互斥锁

背景: 实现单机版任务调度的功能(分布式后续考虑,暂时先单进程) 1.首先管理员启动整个任务,并设置执行权限   2.工作节点收到消息后就会创建对应的线程,并开始执行任务(任务都是由一个管理员进行分配)   3.运行过程中管理员需要临时中断某个任务,需要设置一个互斥信号,此时对应的工作节点都需要被阻塞,注意不是完全销毁 import java.util.concurrent.Callab

luxianping的专栏 757

LSTM在DNA序列分析中的应用:生物信息学的探索

长短期记忆网络(LSTM)是循环神经网络(RNN)的一个变种,旨在解决RNN在长序列数据中出现的梯度消失和梯度爆炸问题。LSTM通过引入“记忆单元”和三个门(输入门、遗忘门和输出门)来有效捕捉长距离依赖关系。这使得LSTM在处理DNA序列等时间序列数据时具有优势。LSTM在DNA序列分析中展现了强大的能力,能够捕捉复杂的序列特征,并提供高效的解决方案。本文从LSTM的基本原理、DNA序列特性、模型构建、训练过程到实际应用进行了详细阐述。

斌擎科技 753

Zookeeper分布式锁实现

zookeeper最初设计的初衷就是为了保证分布式系统的一致性。本文将讲解如何利用zookeeper的临时顺序结点,实现分布式锁。

2301_76632762的博客 1373

OpenClaw部署太难?汉化版+中文社区+国产替代品,国内用户零门槛指南

OpenClaw作为GitHub 10万+星的开源AI助手平台,近期在国内AI圈备受关注 🌟 但部署难度和英文界面让很多用户望而却步。本文整理了针对国内用户的友好资源和简便替代方案,帮助国内用户零门槛上手AI助手工具 🚀

XiaoqiangClub的博客 5759

华为OD机试 双机位A卷 - 流量波峰 (C++ & Python & JAVA & JS & GO)

华为OD机试双机位A卷 流量波峰,提供Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解

qq_45776114的博客 1378

图解curator如何实现zookeeper分布式锁

curator提供的四种分布式锁概述(InterProcessMutex、InterProcessSemaphoreMutex、InterProcessReadWriteLock、InterProcessMultiLock),Zookeeper分布式锁实现思路,Zookeeper分布式锁解决的问题,Zookeeper分布式锁优缺点,InterProcessMutex实现zookeeper分布式原理/源码解析,图解curator解锁 / 解锁流程

健身变秃,coding变强 1万+

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

ZooKeeper实现分布式锁

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

qq_28136919的博客 4819

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

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

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

KIMTOU的博客 1万+

zookeeper - 实现分布式锁

zookeeper - 实现分布式锁

qq_43350524的博客 1404

Zookeeper 及 基于ZooKeeper实现的分布式锁

ZooKeeper是一个开源的分布式协调服务,它的设计目标是将那些复杂且容易出错的分布式一致性服务封装起来,构成一个高效可靠的原语集,并以一系列简单易用的接口提供给用户使用。原语:操作系统或计算机网络用语范畴。是由若干条指令组成的,用于完成一定功能的一个过程。具有不可分割性,即原语的执行必须是连续的,在执行过程中不允许被中断。

rc1596919047的博客 1572

zookeeper实现分布式锁-curator

前言 在之前《Redis实现分布式锁》一文中我已经介绍了使用Redis实现分布式锁原理,今天主要是介绍一下如何使用zookeeper实现分布式锁。 一.zookeeper介绍和安装 1.zookeeper介绍 1.1.什么是zookeeper ZooKeeper由雅虎研发,是Google Chubby的开源实现,目前托管给Apache,是一个经典的分布式数据一致性解决方案,致力于为分布式应用提供一个高性能、高可用,且具有严格顺序访问控制能力的分布式协调服务。 分布式应用程序可以基于ZooKeeper实现数

墨家巨子@俏如来 2921

Zookeeper 分布式锁原理与实现

在分布式系统中,确保多个进程或服务实例在访问共享资源时能够互斥,是保证数据一致性和系统稳定性的关键。一个典型的场景是,当多个服务实例需要同时更新同一份数据时,如果没有适当的机制来控制访问顺序,可能会导致数据冲突或不一致。为了解决这个问题,分布式锁应运而生。接下来,我们将深入探讨Zookeeper在实现分布式锁方面的知识。分布式锁是分布式系统中的一种同步机制,它允许多个进程或服务实例在分布式环境中对共享资源进行互斥访问。

我是Java程序员廖志伟,感谢朋友们的支持!不定期贡献一篇高品质、过万文字、图文并茂且附有视频解说、满载代码示例注释的良心之作,坚决杜绝粗制乱造。 923

基于Zookeeper实现分布式锁

在Zookeeper中的指定路径下创建创建节点,然后客户端根据当前路径下的节点状态来判断是否加锁成功,如下图一种情况为例,线程1创建节点成功后,线程2再去创建节点就会创建失败。(3)如果加锁次数等于0,则释放锁,删除掉创建的临时节点,下一个监听这个节点的客户端会感知到节点删除事件,从而重新去获取锁。3:判断自己的序号是否最小,如果最小的话,代表加锁成功,如果不是最小的话,就对前一个节点创建监听器。2:使用顺序节点的好处是,可以利用锁释放的事件监听机制,来实现。2:第二步客户端拿到加锁路径下所有创建的节点。

weixin_45125989的博客 2916
上一篇: mybatis 分页拦截器,经网上资料修改可用
下一篇: 微软100题,39题
hxpjava1
博客等级 码龄19年 1365粉丝 511原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

hxpjava1

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

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

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

打赏作者

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

抵扣说明:

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

余额充值