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

最新推荐文章于 2024-01-06 15:23:51 发布
最新推荐文章于 2024-01-06 15:23:51 发布
阅读量854 收藏 4
点赞数 1
分类专栏： zookeeper 文章标签： zookeeper 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22701869/article/details/115420612
版权

目录

 

1、zookeeper节点特点

2、分布式锁实现

2.1 lock自定义

2.2 抽象方法，使用模板模式定义好获取锁的方法

2.3 具体的工具类锁

2.4 使用测试类

2.5 输出结果

1、zookeeper节点特点

  • 临时节点（EPHEMERAL） ：session链接断开就没了；不能创建子节点；不能同名
  • 临时顺序节点（EPHEMERAL_SEQUENTIAL） ：session链接断开就没了；不能创建子节点；同名节点会在后面添加上序号（分布式锁使用的好处）
  • 持久节点（PERSISTENT）：session断联、服务端重启还在；可以创建子节点，子节点可以临时也可以持久；不能同名
  • 持久顺序节点（PERSISTENT_SEQUENTIAL）：session断联、服务端重启还在；可以创建子节点，子节点可以临时也可以持久；同名节点会在后面添加上序号

1.1 图解

2、分布式锁实现

参考ReentrantLock实现的Lock接口，主要有tryLock(),lock(),unLock()方法

2.1 lock自定义

public interface Lock {
    /**
     * 获取锁
     */
    void getLock();

    /**
     * 释放锁
     */
    void unLock();
}

2.2 抽象方法，使用模板模式定义好获取锁的方法

public abstract class AbstractZkLock implements Lock {
    //使用了模板方法，开放使用的只有getLock和unLock方法
    @Override
    public void getLock() {
        if (tryLock()) {
            System.out.println("获取锁");
        } else {
            //未获取到锁等待
            waitLock();
            //获取到锁之后，唤醒
            getLock();
        }
    }

    /**
     * ②占有锁
     *
     * @return 获取锁返回true
     */
    public abstract boolean tryLock();

    /**
     * 等待
     */
    public abstract void waitLock();
}

2.3 具体的工具类锁

public class ZkDistributeLock extends AbstractZkLock {
    //连接zk服务器
    private ZkClient zkClient = new ZkClient("127.0.0.1:21810");
    //作为锁的父节点
    private static final String PATH_LOCK = "/zk_path_lock";

    //要获取锁的前一个节点
    private String beforePath = null;
    //当前要获取锁的节点
    private String currentPath = null;
    private CountDownLatch countDownLatch;

    ZkDistributeLock() {
        //先创建一个持久节点作为分布式锁的父节点
        if (!zkClient.exists(PATH_LOCK)) {
            zkClient.createPersistent(PATH_LOCK, PATH_LOCK);
        }
    }

    @Override
    public boolean tryLock() {
        //首次进来肯定是空的
        if (currentPath == null || currentPath.length() == 0) {
            //currentpath = /zk_path_lock/0000000144
            currentPath = zkClient.createEphemeralSequential(PATH_LOCK + "/", PATH_LOCK);
        }
        //获取所有临时节点并排序0000000196,0000000196,0000000196
        List<String> children = zkClient.getChildren(PATH_LOCK);
        //对所有子节点排序
        Collections.sort(children);
        //判断当前节点是不是第一个节点
        if (currentPath.equals(PATH_LOCK + "/" + children.get(0))) {
            return true;
        } else {
            //找到当前节点的下标
            System.out.println(children.toString());
            //currentPath要去掉前面的PATH_LOCK + "/"字符串
            int wz = Collections.binarySearch(children, currentPath.substring((PATH_LOCK + "/").length()));
            System.out.println(wz);
            beforePath = PATH_LOCK + '/' + children.get(wz - 1);
        }
        return false;
    }

    @Override
    public void waitLock() {
        IZkDataListener zkDataListener = new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {

            }

            @Override
            public void handleDataDeleted(String s) throws Exception {
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }
        };
        //给排在前面的的节点增加数据删除的watcher,本质是启动另外一个线程去监听前置节点
        zkClient.subscribeDataChanges(beforePath, zkDataListener);
        try {
            if (zkClient.exists(beforePath)) {
                countDownLatch = new CountDownLatch(1);
                countDownLatch.await();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        zkClient.unsubscribeDataChanges(beforePath, zkDataListener);
    }

    @Override
    public void unLock() {
        zkClient.delete(currentPath);
        //每次实例化的时候，都会创建一个连接，所以要关闭
        zkClient.close();
    }
}

2.4 使用测试类

public class TestMain extends Thread {
    private ZkDistributeLock lock = new ZkDistributeLock();
    //全局订单id
    private static int count = 0;
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");

    public static void main(String[] args) {
        for (int i = 0; i < 50; i++) {
            new Thread(new TestMain()).start();
        }
    }

    @Override
    public void run() {
        lock.getLock();
        try {
            String number = dateFormat.format(new Date()) + "-" + ++count;
            System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unLock();
        }
    }
}

2.5 输出结果

获取锁
Thread-2,生成订单ID:2021-04-03-21-08-57-1
获取锁
Thread-5,生成订单ID:2021-04-03-21-08-57-2
获取锁
Thread-8,生成订单ID:2021-04-03-21-08-57-3
获取锁
Thread-11,生成订单ID:2021-04-03-21-08-57-4
获取锁
Thread-14,生成订单ID:2021-04-03-21-08-57-5
获取锁
Thread-17,生成订单ID:2021-04-03-21-08-57-6
获取锁
Thread-20,生成订单ID:2021-04-03-21-08-57-7
获取锁
Thread-23,生成订单ID:2021-04-03-21-08-57-8
获取锁
Thread-26,生成订单ID:2021-04-03-21-08-57-9
获取锁
Thread-29,生成订单ID:2021-04-03-21-08-57-10
获取锁
Thread-32,生成订单ID:2021-04-03-21-08-57-11
获取锁
Thread-35,生成订单ID:2021-04-03-21-08-57-12
获取锁
Thread-38,生成订单ID:2021-04-03-21-08-57-13
获取锁
Thread-41,生成订单ID:2021-04-03-21-08-57-14
获取锁
Thread-44,生成订单ID:2021-04-03-21-08-57-15
获取锁
Thread-47,生成订单ID:2021-04-03-21-08-57-16
获取锁
Thread-50,生成订单ID:2021-04-03-21-08-57-17
获取锁
Thread-53,生成订单ID:2021-04-03-21-08-57-18
获取锁
Thread-56,生成订单ID:2021-04-03-21-08-57-19
获取锁
Thread-59,生成订单ID:2021-04-03-21-08-57-20
获取锁
Thread-62,生成订单ID:2021-04-03-21-08-57-21
获取锁
Thread-65,生成订单ID:2021-04-03-21-08-57-22
获取锁
Thread-68,生成订单ID:2021-04-03-21-08-57-23
获取锁
Thread-71,生成订单ID:2021-04-03-21-08-57-24
获取锁
Thread-74,生成订单ID:2021-04-03-21-08-57-25
获取锁
Thread-77,生成订单ID:2021-04-03-21-08-57-26
获取锁
Thread-80,生成订单ID:2021-04-03-21-08-57-27
获取锁
Thread-83,生成订单ID:2021-04-03-21-08-57-28
获取锁
Thread-86,生成订单ID:2021-04-03-21-08-57-29
获取锁
Thread-89,生成订单ID:2021-04-03-21-08-57-30
获取锁
Thread-92,生成订单ID:2021-04-03-21-08-57-31
获取锁
Thread-95,生成订单ID:2021-04-03-21-08-57-32
获取锁
Thread-98,生成订单ID:2021-04-03-21-08-57-33
获取锁
Thread-101,生成订单ID:2021-04-03-21-08-57-34
获取锁
Thread-104,生成订单ID:2021-04-03-21-08-57-35
获取锁
Thread-107,生成订单ID:2021-04-03-21-08-57-36
获取锁
Thread-110,生成订单ID:2021-04-03-21-08-57-37
获取锁
Thread-113,生成订单ID:2021-04-03-21-08-57-38
获取锁
Thread-116,生成订单ID:2021-04-03-21-08-57-39
获取锁
Thread-119,生成订单ID:2021-04-03-21-08-57-40
获取锁
Thread-122,生成订单ID:2021-04-03-21-08-57-41
获取锁
Thread-125,生成订单ID:2021-04-03-21-08-57-42
获取锁
Thread-128,生成订单ID:2021-04-03-21-08-57-43
获取锁
Thread-131,生成订单ID:2021-04-03-21-08-57-44
获取锁
Thread-134,生成订单ID:2021-04-03-21-08-57-45
获取锁
Thread-137,生成订单ID:2021-04-03-21-08-57-46
获取锁
Thread-140,生成订单ID:2021-04-03-21-08-57-47
获取锁
Thread-143,生成订单ID:2021-04-03-21-08-57-48
获取锁
Thread-146,生成订单ID:2021-04-03-21-08-57-49
获取锁
Thread-149,生成订单ID:2021-04-03-21-08-57-50

 

黑皮爱学习
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zookeeper节点详解
孤岛的鲸
03-20 1145
一、节点类型 persistent 持久节点 persistent_sequential 持久序号节点 ephemeral 临时节点 ephemeral_sequential 临时序号节点 1.persistent 持久节点 默认创建的节点 创建方式 create /newNode 2.persistent_sequential 持久序号节点 给创建的持久节点...
基于zookeeper实现分布式锁
热门推荐
sunfeizhi的专栏
07-16 8万+
前言：2016春节之后一直比较忙，因此博客N个没有更新，现在也是忙里偷闲，偷偷的更新一篇！ 一、分布式锁介绍         分布式锁主要用于在分布式环境中保护跨进程、跨主机、跨网络的共享资源实现互斥访问，以达到保证数据的一致性。 二、架构介绍         在介绍使用Zookeeper实现分布式锁之前，首先看当前的系统架构图
JavaScript超级入门基础(一)
qq_44972915的博客
09-05 467
JavaScript基础(一) HTML-DOM （一）什么是 HTML DOM？ HTML DOM 是： HTML 的标准对象模型 HTML 的标准编程接口 W3C 标准 HTML DOM 定义了所有 HTML 元素的对象和属性，以及访问它们的方法。换言之，HTML DOM 是关于如何获取、修改、添加或删除 HTML 元素的标准。 （二）HTML节点： HTML文档中的每个成分都是一个节点。 整个文档是一个文档节点(Document) 每个 HTML 标签是一个元素节点(Element)
Zookeeper原理--分布式锁
IT利刃出鞘的博客
01-30 2821
其他网址 三种实现分布式锁的方式_vincent-CSDN博客_分布式锁、 节点 其他网址 《从Paxos到Zookeeper 分布式一致性原理与实践》=>4.1.3 ZooKeeper的基本概念 让我们来回顾一下Zookeeper节点的概念： Zookeeper的数据存储结构就像一棵树，这棵树由节点组成，这种节点叫做Znode。Znode分为四种类型： 1.持久节点 （PERSISTENT） 默认的节点类型。创建节点的客户端与Zookeeper断开连接...
（十）、ZNode节点类型
tiger的专栏
10-13 4336
ZooKeeper节点类型： ZooKeeper 节点是有生命周期的，这取决于节点的类型。在 ZooKeeper 中，节点类型可以分为持久节点（PERSISTENT ）、临时节点（EPHEMERAL），以及时序节点（SEQUENTIAL ），具体在节点创建过程中，一般是组合使用，可以生成以下 4 种节点类型。 持久节点（PERSISTENT）持久顺序节点（PERSISTENT_SEQU
分布式锁-zk临时节点
qq_33240556的博客
08-08 1026
多线程访问同一个共享资源时，会出现并发问题，synchronized或者lock 类的锁只能控制单一进程的资源访问，多进程下就需要用到分布式锁 利用zk 可以实现独占锁，(同级节点唯一性)多个进程往zk指定节点下创建一个相同名称的节点，只有一个能成功，创建失败的通过zk的watcher机制监听子节点变化，一个监听到子节点删除事件，会再次触发所有进程的写锁，但这里会有惊群效应，会影响到性能 利用有序节点实现分布式锁：每个客户端都往一个指定节点(locks)注册一个临时有序节点，越早创建的节点编号越小，最小编号
zookeeper 创建临时顺序节点_分布式锁Zookeeper方案
weixin_39767513的博客
11-23 423
1. Redis分布式锁回顾为了避免持有分布式锁的进程(线程)崩溃造成死锁的情况，上篇文章谈到的两种redis实现方案都为redis的key设置了定时失效。但是这种定时失效又会因为网路IO，GC影响造成在同一时间多个进程持有同一把锁的互斥性情况。这篇文章介绍一种新的分布式锁实现方案，也就是Zookeeper分布式锁方案，Zookeeper分布式锁的正确性远高于Redis分布式锁。2. Zookee...
分布式锁3: zk实现分布式锁3 使用临时顺序节点+watch监听实现阻塞锁
最新发布
健康平安的活着的专栏
01-06 711
接上一篇文章，每个请求要想正常的执行完成，最终都是要创建节点，如果能够避免争抢必然可以提高性能。这里借助于zk的临时序列化节点，实现分布式锁1. 主要修改了构造方法和lock方法：2.并添加了getPreNode获取前置节点的方法。存在的问题就是羊群效应。
zookeeper客户端基本命令
liuerchong的博客
03-30 943
创建节点，create [-s] [-e] [-c] [-t ttl] path [data] [acl] 节点类型 | 类型 | 描述 | |:----|:----| | PERSISTENT | 持久节点 | | PERSISTENT_SEQUENTIAL | 持久序号节点 | | EPHEMERAL | 临时节点(不可在拥有子节点) | | EPHE...
Zookeeper原理详解
qq_20161461的博客
08-02 1万+
Zookeeper是什么 Zookeeper 分布式服务框架是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等 Zookeeper 作为一个分布式的服务框架，主要用来解决分布式集群中应用系统的一致性问题，它能提供基于类似于文件系统的目录节点树方式的数据存储， Zookeeper 作用主要是用来维护和监控存储的数据的状态变化，通过监控这些数据状态的变化，从而达到基于数据的集群管理 简单的说，zo
基于zookeeper临时顺序节点实现分布式调度
04-11
利用zookeeper的临时顺序节点实现分布式锁，同时控制多个quartz示例协作执行的代码。
zookeeper的四种节点：临时、临时顺序、持久、持久顺序特点详解
一点光辉的博客
04-02 9639
zk四种节点的区别
三种实现分布式锁的方式
develop
07-17 355
一、为什么要使用分布式锁 我们在开发应用的时候，如果需要对某一个共享变量进行多线程同步访问的时候，可以使用我们学到的Java多线程的18般武艺进行处理，并且可以完美的运行，毫无Bug！ 注意这是单机应用，也就是所有的请求都会分配到当前服务器的JVM内部，然后映射为操作系统的线程进行处理！而这个共享变量只是在这个JVM内部的一块内存空间！ 后来业务发展，需要做集群，一个应用需要部署到几台机器上然后做负载均衡，大致如下图： 上图可以看到，变量A存在JVM1、JVM2、JVM3三个JVM内存中（这个
基于Zookeeper实现多进程分布式锁
weixin_30883777的博客
11-14 235
一、zookeeper简介及基本操作 Zookeeper并不是用来专门存储数据的，它的作用主要是用来维护和监控你存储的数据的状态变化。当对目录节点监控状态打开时，一旦目录节点的状态发生变化，Watcher对象的process方法就会被调用。 创建Zookeeper实例时即可绑定一个Watcher对象，如 ZooKeeperzk = new ZooKeeper(zookeep...
基于Zookeeper实现的分布式锁
C18818264842的博客
10-15 280
zookeeper由于其node path的唯一性，也具备实现分布式锁的天然条件。同时得益于其watch机制在实现起来更方便。 本文基于golang实现的zookeeper分布式锁，仅供参考。使用的第三方library是github.com/samuel/go-zookeeper/zk . GetLock: GetLock相对来说比较复杂。 Zookeeper在create key的时候可以选择不同模式： currPath, err := conn.Create(zkKey, nil, 3, zk.Worl
基于ZooKeeper临时顺序节点的分布式锁实现
m0_51561690的博客
04-27 243
基于临时顺序节点的锁实现原理是，在ZooKeeper中创建一个临时顺序节点，每个客户端都可以创建这样的节点。如果是，那么它获得了锁，如果不是，那么它会监视比自己小的节点的删除事件，直到这些节点被删除，然后再次尝试获取锁。与临时节点不同的是，临时顺序节点也会根据节点的创建顺序为节点分配一个唯一的编号。基于临时节点的锁实现原理是，在ZooKeeper中创建一个临时节点，这个节点就是锁的代表。如果应用场景中锁的获取和释放频率较高，且需要保证客户端获取锁的顺序和避免死锁的情况，那么基于临时顺序节点的锁更为合适。
【面试】实现分布式锁的三种方式
m0_64210833的博客
08-07 6839
在单击环境下，就是只有当前JVM虚拟机A中的多个线程对同一个Object（共享资源）进行操作，可以采用同步互斥（就是只有同一时间只有一个线程对共享资源进行事务操作）的方式，我们常用的方式就是采用加锁的方式解决，虽然不能保证数据的强一致性，但是能够保证数据的最终一致性。........................
Docker 下的Zookeeper以及.ne core 的分布式锁
dz45693的专栏
08-16 2504
单节点 1.拉取镜像：docker pull zookeeper 2.运行容器 a.我的容器同一放在/root/docker下面，然后创建相应的目录和文件， mkdir zookeeper cd zookeeper mkdir data mkdir datalog mkdir conf cd conf touch zoo.cfg 其中zoo.cfg(这里是默认的主要延时怪哉文件)如下：...
ZK（ZooKeeper）分布式锁实现
fygkchina的专栏
08-30 3484
在平时我们对锁的使用，在针对单个服务，我们可以用 Java 自带的一些锁来实现，资源的顺序访问，但是随着业务的发展，现在基本上公司的服务都是多个，单纯的 Lock或者Synchronize 只能解决单个JVM线程的问题，那么针对于单个服务的 Java 的锁是无法满足我们业务的需要的，为了解决多个服务跨服务访问共享资源，于是就有了分布锁，分布式锁产生的原因就是集群。...
ZooKeeper怎么实现分布式锁
05-30
ZooKeeper可以通过创建临时节点来实现分布式锁。具体实现步骤如下： 1. 在ZooKeeper中创建一个名为lock的持久节点。 2. 当一个客户端需要获取锁时，它在lock节点下创建一个顺序临时节点。 3. 客户端获取lock节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值