利用ZooKeeper简单实现分布式锁

基于ZooKeeper的分布式锁是一种利用ZooKeeper提供的临时节点和顺序节点特性来实现的分布式锁机制 基于ZooKeeper的分布式锁是一种利用ZooKeeper提供的临时节点和顺序节点特性来实现的分布式锁机制。临时节点的特点是,当客户端会话结束或断开连接时,这些节点会自动被删除。例如,一个客户端可以创建一个临时节点来表示它正在尝试获取某个锁,如果该客户端失去连接,这个临时节点会自动消失,从而释放锁。:临时节点也可以是顺序节点,即在创建时,ZooKeeper会在节点名称后附加一个单调递增的数字后缀。的临时节点,并设置了节点的数据和权限。:在ZooKeeper中,临时节点不能有子节点。方法来更新节点数据。 阅读详情

利用ZooKeeper简单实现分布式锁

原创  2016年09月18日 09:00:17
  • 8525

下面讲解下怎么利用ZooKeeper简单实现分布式锁,对于zk的安装和简单使用请参考我的文章:Hadoop集群之 ZooKeeper和Hbase环境搭建


全部代码下载:优快云链接:优快云链接;写文章不易,欢迎大家采我的文章,以及给出有用的评论,当然大家也可以关注一下我的github;多谢;

1.分布式锁的由来:

在程序开发过程中不得不考虑的就是并发问题。在java中对于同一个jvm而言,jdk已经提供了lock和同步等。但是在分布式情况下,往往存在多个进程对一些资源产生竞争关系,而这些进程往往在不同的机器上,这个时候jdk中提供的已经不能满足。分布式锁顾明思议就是可以满足分布式情况下的并发锁。 下面我们讲解怎么利用zk实现分布式锁。

2.实现思路:

2.1 zk简单介绍:

ZooKeeper是Apache软件基金会的一个软件项目,他为大型分布式计算提供开源的分布式配置服务、同步服务和命名注册。在 ZooKeeper 中,节点类型可以分为持久节点(PERSISTENT )、临时节点(EPHEMERAL),以及时序节点(SEQUENTIAL ),具体在节点创建过程中,一般是组合使用,可以生成 4 种节点类型:持久节点(PERSISTENT),持久顺序节点(PERSISTENT_SEQUENTIAL),临时节点(EPHEMERAL),临时顺序节点(EPHEMERAL_SEQUENTIAL);具体节点含义,谷歌之。

2.2 利用zk实现:

当很多进程需要访问共享资源时,我们可以通过zk来实现分布式锁。主要步骤是: 
1.建立一个节点,假如名为:lock 。节点类型为持久节点(PERSISTENT) 
2.每当进程需要访问共享资源时,会调用分布式锁的lock()或tryLock()方法获得锁,这个时候会在第一步创建的lock节点下建立相应的顺序子节点,节点类型为临时顺序节点(EPHEMERAL_SEQUENTIAL),通过组成特定的名字name+lock+顺序号。 
3.在建立子节点后,对lock下面的所有以name开头的子节点进行排序,判断刚刚建立的子节点顺序号是否是最小的节点,假如是最小节点,则获得该锁对资源进行访问。 
4.假如不是该节点,就获得该节点的上一顺序节点,并给该节点是否存在注册监听事件。同时在这里阻塞。等待监听事件的发生,获得锁控制权。 
5.当调用完共享资源后,调用unlock()方法,关闭zk,进而可以引发监听事件,释放该锁。 
实现的分布式锁是严格的按照顺序访问的并发锁。

3.代码实现:

下面将讲解使用java实现分布式锁: 
1.建立类DistributedLock,实现java.util.concurrent.locks.Lock;和org.apache.zookeeper.Watcher接口 
2.实现lock下面的方法:主要包括lock,tryLock,unlock等 
3.实现watcher接口下的process方法。 
4.在构造器中对zk进行初始化。 
5.详细见代码注释

package cn.wpeace.zktest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.Stat;
/**
 * @author peace
 *
 */
public class DistributedLock implements Lock, Watcher{
    private ZooKeeper zk;
    private String root = "/locks";//根
    private String lockName;//竞争资源的标志
    private String waitNode;//等待前一个锁
    private String myZnode;//当前锁
    private CountDownLatch latch;//计数器
    private CountDownLatch connectedSignal=new CountDownLatch(1);
    private int sessionTimeout = 30000; 
    /**
     * 创建分布式锁,使用前请确认config配置的zookeeper服务可用
     * @param config 192.168.1.127:2181
     * @param lockName 竞争资源标志,lockName中不能包含单词_lock_
     */
    public DistributedLock(String config, String lockName){
        this.lockName = lockName;
        // 创建一个与服务器的连接
         try {
            zk = new ZooKeeper(config, sessionTimeout, this);
            connectedSignal.await();
            Stat stat = zk.exists(root, false);//此去不执行 Watcher
            if(stat == null){
                // 创建根节点
                zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
            }
        } catch (IOException e) {
            throw new LockException(e);
        } catch (KeeperException e) {
            throw new LockException(e);
        } catch (InterruptedException e) {
            throw new LockException(e);
        }
    }
    /**
     * zookeeper节点的监视器
     */
    public void process(WatchedEvent event) {
        //建立连接用
        if(event.getState()==KeeperState.SyncConnected){
            connectedSignal.countDown();
            return;
        }
        //其他线程放弃锁的标志
        if(this.latch != null) {  
            this.latch.countDown();  
        }
    }

    public void lock() {   
        try {
            if(this.tryLock()){
                System.out.println("Thread " + Thread.currentThread().getId() + " " +myZnode + " get lock true");
                return;
            }
            else{
                waitForLock(waitNode, sessionTimeout);//等待锁
            }
        } catch (KeeperException e) {
            throw new LockException(e);
        } catch (InterruptedException e) {
            throw new LockException(e);
        } 
    }
    public boolean tryLock() {
        try {
            String splitStr = "_lock_";
            if(lockName.contains(splitStr))
                throw new LockException("lockName can not contains \\u000B");
            //创建临时子节点
            myZnode = zk.create(root + "/" + lockName + splitStr, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println(myZnode + " is created ");
            //取出所有子节点
            List<String> subNodes = zk.getChildren(root, false);
            //取出所有lockName的锁
            List<String> lockObjNodes = new ArrayList<String>();
            for (String node : subNodes) {
                String _node = node.split(splitStr)[0];
                if(_node.equals(lockName)){
                    lockObjNodes.add(node);
                }
            }
            Collections.sort(lockObjNodes);

            if(myZnode.equals(root+"/"+lockObjNodes.get(0))){
                //如果是最小的节点,则表示取得锁
                System.out.println(myZnode + "==" + lockObjNodes.get(0));
                return true;
            }
            //如果不是最小的节点,找到比自己小1的节点
            String subMyZnode = myZnode.substring(myZnode.lastIndexOf("/") + 1);
            waitNode = lockObjNodes.get(Collections.binarySearch(lockObjNodes, subMyZnode) - 1);//找到前一个子节点
        } catch (KeeperException e) {
            throw new LockException(e);
        } catch (InterruptedException e) {
            throw new LockException(e);
        }
        return false;
    }
    public boolean tryLock(long time, TimeUnit unit) {
        try {
            if(this.tryLock()){
                return true;
            }
            return waitForLock(waitNode,time);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    private boolean waitForLock(String lower, long waitTime) throws InterruptedException, KeeperException {
        Stat stat = zk.exists(root + "/" + lower,true);//同时注册监听。
        //判断比自己小一个数的节点是否存在,如果不存在则无需等待锁,同时注册监听
        if(stat != null){
            System.out.println("Thread " + Thread.currentThread().getId() + " waiting for " + root + "/" + lower);
            this.latch = new CountDownLatch(1);
            this.latch.await(waitTime, TimeUnit.MILLISECONDS);//等待,这里应该一直等待其他线程释放锁
            this.latch = null;
        }
        return true;
    }
    public void unlock() {
        try {
            System.out.println("unlock " + myZnode);
            zk.delete(myZnode,-1);
            myZnode = null;
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }
    public void lockInterruptibly() throws InterruptedException {
        this.lock();
    }
    public Condition newCondition() {
        return null;
    }

    public class LockException extends RuntimeException {
        private static final long serialVersionUID = 1L;
        public LockException(String e){
            super(e);
        }
        public LockException(Exception e){
            super(e);
        }
    }
}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170

4.测试:

1.下载我的工程代码:点击下载 
2.或者直接使用该类:

 DistributedLock lock   = new DistributedLock("192.168.1.127:2181","lock");
 lock.lock();
 //共享资源
 if(lock != null)
  lock.unlock();  
  • 1
  • 2
  • 3
  • 4
  • 5

3.执行步骤: 
1.启动zk:zkServer.sh start 
2.启动测试代码 
3.执行结果: 
05 
06

本文来自伊豚(blog.wpeace.cn)

别再调参了!用Simulink手把手教你搞定FOC电机速度环PI控制器(附模型下载) 本文详细介绍了如何使用Simulink搭建FOC电机速度环PI控制器,通过模最优准则和系统化调试方法,避免传统手动调参的繁琐过程。文章包含从传递函数推导到参数自动整定的完整流程,并提供了实战调试技巧与异常处理指南,帮助工程师快速实现电机控制系统的稳定运行。 阅读详情

相关推荐

nacos3.1.0适配国产数据库

Nacos 3.1.0适配国产数据库指南 本文介绍了Nacos 3.1.0版本适配达梦数据库和人大金仓数据库的具体步骤。主要内容包括:添加达梦和人大金仓的JDBC驱动依赖,修改nacos-persistence模块的配置文件及相关Java类,以及打包和运行注意事项。文章特别指出3.1.0版本需要JDK17环境,并提供了解决常见问题的建议,如添加VM options配置和不同启动方式等。通过本文的配置指导,可以实现Nacos服务在国产数据库环境下的正常运行。

梦昼初的博客 1467

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

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

KIMTOU的博客 1万+

手把手教你搭建三端口DC-DC变换器(含Boost+Buck电路实战)

本文详细介绍了如何从零开始搭建三端口DC-DC变换器,涵盖Boost和Buck电路的硬件设计、元器件选型、电路板布局、焊接技巧、控制系统设计与调试等关键步骤。通过实战案例和优化建议,帮助工程师避开常见陷阱,提升系统效率和稳定性,适用于光伏、储能等电力电子应用场景。

x8y9z0的博客 938

基于Zookeeper实现分布式锁

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

weixin_45125989的博客 2916

从零搭建一个AF架构项目:基于TIA Portal V19和S7-PLCSIM的仿真调试全流程

本文详细介绍了如何在TIA Portal V19环境中从零搭建西门子Automation Framework(AF架构)项目,包括环境准备、硬件组态、核心组件创建、项目架构分层实现以及仿真调试全流程。通过模块化编程和标准化接口设计,AF架构显著提升工业自动化项目的开发效率和维护便利性,特别适合S7-1500系列PLC的应用开发。

weixin_29313547的博客 677

3GPP协议解读_NTN系列(一)_38.811_非地面网络(NTN)的背景、应用场景和信道建模

非地面网络覆盖广,对物理攻击和自然灾害有一定的抵抗性。本文根据3GPP协议对NTN网络的背景、应用场景和信道模型进行了整理。

JCMLSY的博客 4933

zookeeper实现分布式锁

介绍了Zookeeper如何实现分布式锁,并使用代码进行了演示

凉茶铺的博客 6972

深入MIPI DSI显示技术栈 (三) DSI vs CSI-2:孪生协议的本质差异

MIPI协议中的DSI与CSI-2存在本质差异:DSI为输出导向协议(Host→Display),用于屏幕控制和画面传输;CSI-2为输入导向协议(Sensor→Host),专攻图像采集。二者在包结构、同步机制、物理层优化等方面均有显著区别:DSI支持命令包和BLLP包,CSI-2具备嵌入式数据包;DSI时钟模式以Burst为主,CSI-2支持Continuous模式。典型场景中,二者协同工作(如手机相机预览),需注意时序同步和延迟控制。设计混合系统时,需合理规划虚拟通道和物理层资源,充分发挥这对&quot

GateWorld的博客 2110

常见的分布式锁--ZooKeeper如何实现分布式锁?

ZooKeeper是一个开源的分布式协调服务,提供了一种分布式锁的实现方式。在ZooKeeper中,可以使用临时节点和顺序节点的特性来实现分布式锁。本文将介绍ZooKeeper的分布式锁实现原理,并提供一个实战代码示例,通过分析关键技术来帮助理解。

IT_WEH_coder的博客 2326

Opencv项目实战:09 物体尺寸测量

《Opencv项目实战:09 物体尺寸测量》本项目主要是运用了之前扫描文档的思想,以A4纸为背景,检测其中区域的物体长和宽。我的摄像头无法固定,所以是手持的,且由于我在寝室里面是真的没有找到合适的测量物体以及背景色(全是米色或原木色的)。所以效果有所欠缺,但经过ps修改的图片,检测的效果还是很不错的。

m0_62919535的博客 1万+

双重分组进位跳跃进位链

跳跃进位链

qq_62260432的博客 942

利用ZooKeeper特性实现分布式锁

利用ZooKeeper特性实现分布式锁 ​ 在单机应用中,常常会遇到多进程/线程竞争系统资源的情况,为了保持多进程/线程情况下数据的一致性,在计算机中引入了锁的概念,从而 保证在多进程/线程情况下,一个系统资源在某个CPU事件片内只有一个进程/线程能够访问。但是在分布式系统的情况下,数据不再是某一台机器进行维护,而是多个系统,多个机器进行维护,根据单机中的锁的概念,人们又衍生出分布式锁。 ​ ...

i_wonder_how_的博客 7661

MAC-电脑中的user文件夹在哪?

MAC-电脑中的user文件夹在哪?

兴趣是最好的老师 1万+

利用Zookeeper实现 - 分布式锁

微信原文: 利用Zookeeper实现 - 分布式锁 博客原文:利用Zookeeper实现 - 分布式锁 在许多场景中,数据一致性是一个比较重要的话题,在单机环境中,我们可以通过Java提供的并发API来解决;而在分布式环境(会遇到网络故障、消息重复、消息丢失等各种问题)下要复杂得多,常见的解决方案是分布式事务、分布式锁等。 本文主要探讨如何利用Zookeeper来实现分布式锁。 关于分布式锁...

小旋锋 的博客 1569

Camera2Demo

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

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

利用zookeeper的临时顺序节点实现分布式锁

利用zookeeper实现分布式锁的代码有很多,本文只是其中的一种,不再过多的介绍思想,简单说一句,就是高并发下,所有请求都去创建一个临时顺序节点,然后对所有节点进行排序,当前拿到锁的节点执行完成后,删除当前节点,zookeeper通知前一个节点,让前一个节点获得到锁,从而达到顺序执行的目的。 pom依赖: <?xml version="1.0" encoding="UTF-8"?&g...

淘淘联盟 5838

假人有限元模型

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

利用redis和zookeeper实现分布式锁

为何需要分布式锁 简单来说,就是互斥的行为跨了节点,原来的进程间互斥就不起作用了。 比如说,两个节点A和B,都想修改节点C上面的文件,那么这时就需要分布式锁。 整体思想 无论是利用redis还是利用zookeeper,整体思想都是在真正做这件事情之前,去试图加一下锁,这个行为和单节点的加锁解锁是没有区别的。只不过试图加锁这个行为在分布式的情况下变得不一样了。 利用redis实现分布式锁 整体思想就...

zc08291161的博客 216

利用zookeeper实现分布式锁

1.分布式锁的由来:在程序开发过程中不得不考虑的就是并发问题。在java中对于同一个jvm而言,jdk已经提供了lock和同步等。但是在分布式情况下,往往存在多个进程对一些资源产生竞争关系,而这些进程往往在不同的机器上,这个时候jdk中提供的已经不能满足。分布式锁顾明思议就是可以满足分布式情况下的并发锁。 下面我们讲解怎么利用zk实现分布式锁。2.实现思路:2.1 zk简单介绍:ZooKeeper...

qq_36881106的博客 165

zookeeper利用模板设计模式实现分布式锁

1.实现pom文件的导入 2.设置好日志输出的配置 以上为基础配置,当然你的虚拟机要有配置的docker容器zookeeper。 主要思想: a、在获取分布式锁的时候在locker节点下创建节点,释放锁的时候释放该节点。 b、客户端调用createNode方法在path下创建临时顺序节点,然后获取该子节点,注意此时不用设置任何Watcher。 c、客户端获取到所有的节点path之后,那么就认为...

sdTAyhn的博客 315

利用zookeeper手动实现分布式锁

zookeeper手动实现分布式锁,了解一下

Sicimike的博客 3365

利用curator实现的zookeeper分布式锁服务

import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import com.netflix.curator.Ret

xiao_jun_0820的专栏 8197
上一篇: ActiveMQ入门到精通4-消息持久化到Mysql
下一篇: Spring boot Mybatis 整合(注解版)
王树民
博客等级 码龄10年 912粉丝 560原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值