分布式锁3: zk实现分布式锁1 znode节点特性

已于 2024-01-14 11:07:58 修改
阅读量1.2k 收藏 15
点赞数 16
分类专栏： 分布式 文章标签： 分布式 zookeeper
于 2023-11-22 22:33:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011066470/article/details/134563905
版权

一 zk 实现分布式锁

1.1 zk分布式操作命令

1.1.1 常用命令说明

1.查看某个节点下的子节点：  ls /
2.查看某个节点的内容:  get   /zookeeper      
3.创建持久化节点：  create /aa "test"
4.删除节点：  delete /aa 
5.查看节点状态：stat /
6. 设置节点的内容   set /aa "test1"

分布式锁实现原理与最佳实践

1.1.2 znode节点类型

        永久节点：create /path content
        临时节点：create -e /path content 。只要客户端程序断开链接自动删除
        永久序列化节点：create -s /path content 
        临时序列化节点：create -s -e /path content 

1.1.3 znode节点独占排它特性

相同节点具有唯一性，只允许创建一次，具有独占排它的特性。

1.2 zk的4种目录树

zookeeper提供一个多层级的节点命名空间（节点称为znode），每个节点都用一个以斜杠（/）分隔的路径表示，而且每个节点都有父节点（根节点除外），非常类似于文件系统。并且每个节点都是唯一的。znode节点有四种类型：

1.PERSISTENT：永久节点。客户端与zookeeper断开连接后，该节点依旧存在

2.EPHEMERAL：临时节点。客户端与zookeeper断开连接后，该节点被删除

3.PERSISTENT_SEQUENTIAL：永久节点、序列化。客户端与zookeeper断开连接后，该节点依旧存在，只是Zookeeper给该节点名称进行顺序编号

4.EPHEMERAL_SEQUENTIAL：临时节点、序列化。客户端与zookeeper断开连接后，该节点被删除，只是Zookeeper给该节点名称进行顺序编号

1.3 实战操作

1.进入zk客户端

./zkCli.sh        # 查看zk客户端

2.创建节点命令

[zk: localhost:2181(CONNECTED) 12] get /sz
test
[zk: localhost:2181(CONNECTED) 13] set /sz test123
[zk: localhost:2181(CONNECTED) 14] get /sz
test123
[zk: localhost:2181(CONNECTED) 15] 

3.案例

[zk: localhost:2181(CONNECTED) 0] create /aa test  # 创建持久化节点
Created /aa
[zk: localhost:2181(CONNECTED) 1] create -s /bb test  # 创建持久序列化节点
Created /bb0000000001
[zk: localhost:2181(CONNECTED) 2] create -e /cc test  # 创建临时节点
Created /cc
[zk: localhost:2181(CONNECTED) 3] create -e -s /dd test  # 创建临时序列化节点
Created /dd0000000003
[zk: localhost:2181(CONNECTED) 4] ls /   # 查看某个节点下的子节点
[aa, bb0000000001, cc, dd0000000003, zookeeper]
[zk: localhost:2181(CONNECTED) 5] stat /  # 查看某个节点的状态
cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x5
cversion = 3
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 5
[zk: localhost:2181(CONNECTED) 6] get /aa  # 查看某个节点的内容
test
[zk: localhost:2181(CONNECTED) 11] delete /aa  # 删除某个节点
[zk: localhost:2181(CONNECTED) 7] ls /  # 再次查看
[bb0000000001, cc, dd0000000003, zookeeper]

1.4 zk的监听事件

1.4.1 说明

在读取数据时，我们可以同时对节点设置事件监听，当节点数据或结构变化时，zookeeper会通知客户端。当前zookeeper针对节点的监听有如下四种事件：

1.监听节点创建 ：使用监听命令：    stat -w /xx 
2.监听节点删除： 使用监听命令：  stat -w /xx

3.监听节点数据变化：  使用监听命令 ： get -w  /xx

4.监听子节点变化：  使用监听命令  ls   -w   /xxx 

1.4.2 案例，监听节点创建

1.客户端1

2.客户端2

 1.4.3 案例，监听节点删除

1.客户端1

2.客户端2：   stat -w  /bb

1.4.4 案例，监听数据变化

1.客户端1

[zk: localhost:2181(CONNECTED) 28] set /teng 1234
[zk: localhost:2181(CONNECTED) 29] 
2.客户端2：会提示目录/teng 发生了改变

 1.客户端1

2.客户端2

 1.4.5 案例，子节点变化

1.客户端1

2.客户端2： 子节点发生变化

1.5 zk的Java Api的操作

1.java代码

package com.atguigu.distributed.lock.util;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * @ClassName: TestZk
 * @Description: TODO
 * @Author: admin
 * @Date: 2023/12/29 11:21:01 
 * @Version: V1.0
 **/
public class TestZk {
    public static void main(String[] args) throws KeeperException, InterruptedException {
        // 获取zookeeper链接
        CountDownLatch countDownLatch = new CountDownLatch(1);
        ZooKeeper zooKeeper = null;
        try {
            zooKeeper = new ZooKeeper("192.168.43.4:2181", 30000, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (Event.KeeperState.SyncConnected.equals(event.getState())
                            && Event.EventType.None.equals(event.getType())) {
                        System.out.println("获取链接成功。。。。。。" + event);
                        countDownLatch.countDown();
                    }
                    else if(Event.KeeperState.Closed.equals(event.getState())){
                        System.out.println("==================关闭链接成功！！");
                    }
                }
            });
            countDownLatch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
       //创建节点
       createInfo(zooKeeper);
      //判断节点是否存在
        Stat  stat = existInfo(zooKeeper);
      //监听节点
        listenerInfo(zooKeeper);
       //获取节点内容
        getNodenfo(zooKeeper);
        //查询子节点
        getChildrenInfo(zooKeeper);
        //更新节点内容
        updateNodeContent(zooKeeper);
        // 删除一个节点
        System.out.println("version:"+stat.getVersion());
        //-1表示不关心版本号
        zooKeeper.delete("/pabank/aa", -1);
//        if (zooKeeper != null){
//            System.out.println("关闭...");
//            zooKeeper.close();
//        }
        System.out.println("over......");
    }
    /**
    * @author admin
    * @description     创建节点
    * @date 2023/12/29 11:25
    * @param [zooKeeper]
    * @return void
    */
    public static void createInfo( ZooKeeper zooKeeper) throws KeeperException, InterruptedException {
        // 创建一个节点，1-节点路径 2-节点内容 3-节点的访问权限 4-节点类型
        // OPEN_ACL_UNSAFE：任何人可以操作该节点
        //CREATOR_ALL_ACL：创建者拥有所有访问权限
        //READ_ACL_UNSAFE: 任何人都可以读取该节点
        //1.创建一个，任何人都可以操作的永久节点
        System.out.println("eee");
      //  zooKeeper.create("/pabank", "aa".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
       // zooKeeper.create("/pabank/aa", "aa".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        //2.创建一个，任何人都可以操作的临时节点
     //   zooKeeper.create("/pabank/bb", "bb~~".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
//        //3.创建一个，任何人都可以操作的永久顺序节点
       zooKeeper.create("/pabank/cc", "cc~~".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
//        //4.创建一个，任何人都可以操作的临时顺序节点
//        zooKeeper.create("/pabank/dd", "dd~~".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
//        //6.创建一个创建者拥有所有访问权限,可以操作的临时顺序节点
//        zooKeeper.create("/atguigu/dd", "haha~~".getBytes(), ZooDefs.Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("创建成功...");

    }
    /**
    * @author admin
    * @description       创建节点是否存在
    * @date 2023/12/29 11:57
    * @param [zooKeeper]
    * @return void
    */
    public static Stat existInfo(ZooKeeper zooKeeper) throws KeeperException, InterruptedException {
        // 判断节点是否存在
        Stat stat = zooKeeper.exists("/pabank", true);
        if (stat != null){
            System.out.println("当前节点存在！" + stat.getVersion());
        } else {
            System.out.println("当前节点不存在！");
        }
        return stat;
    }
    public static void   listenerInfo(ZooKeeper zooKeeper) throws KeeperException, InterruptedException {
        // 判断节点是否存在，同时添加监听
        zooKeeper.exists("/pabank", event -> {
            System.out.println("监听event:"+event);
        });
    }
    /**
    * @author admin
    * @description       获取节点的数据
    * @date 2023/12/29 16:44
    * @param [zooKeeper]
    * @return void
    */
    public static void  getNodenfo(ZooKeeper zooKeeper) throws KeeperException, InterruptedException {
        // 获取一个节点的数据
        byte[] data = zooKeeper.getData("/pabank/aa", false, null);
        System.out.println("节点内容"+new String(data));
    }
    /**
    * @author admin
    * @description     查询一个节点的所有子节点
    * @date 2024/1/2 17:28
    * @param [zooKeeper]
    * @return void
    */
    public  static void  getChildrenInfo(ZooKeeper zooKeeper) throws KeeperException, InterruptedException {
        // 查询一个节点的所有子节点
        List<String> children = zooKeeper.getChildren("/pabank", false);
        System.out.println("子节点内容children："+children);
    }
    /**
    * @author admin
    * @description       更新节点内容
    * @date 2024/1/2 17:29
    * @param []
    * @return void
    */
    public static void updateNodeContent(ZooKeeper zooKeeper) throws KeeperException, InterruptedException {
        // 更新
        Stat stat=existInfo(zooKeeper);
        zooKeeper.setData("/pabank", "wawa...".getBytes(), stat.getVersion());
        System.out.println("修改内容:"+"wawa");
    }

}

2.执行结果

3.删除节点：  子节点pabank/aa 中 /aa进行了删除

健康平安的活着
关注
  • 16
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis和zookeeper实现分布式锁的区别
01-20
Redis和Zookeeper是两种常用的分布式协调服务，它们都可以用来实现分布式锁，但具体实现方式和特性有所不同。 **Redis分布式锁** Redis作为内存数据库，具有高性能、低延迟的特点，常被用作实现分布式锁。Redis...
zk常用的命令
qq_45260724的博客
01-15 5826
zk的命令
【zk】(一) Zookeeper 常见简单命令
mateo的博客
06-30 3971
zookeeper 常见命令
Zookeeper3.5.7版本——客户端命令行操作（节点删除与查看）
小志的博客
03-09 1633
Zookeeper3.5.7版本——客户端命令行操作（节点删除与查看）
zookeeper之基本使用及实现分布式锁
wang0907的博客
12-29 728
本文一起看下zk的基本用法。安装。
Zookeeper ---- Zookeeper集群操作
在人间负债^
10-27 848
集群模式下配置一个文件 myid，这个文件在 dataDir 目录下，这个文件里面有一个数据就是 A 的值，Zookeeper 启动时读取此文件，拿到里面的数据域 zoo.cfg 里面的配置信息比较从而判断到底是哪个 server。客户端注册监听它关心的目录节点，当目录节点发送变化（数据改变、节点删除、子目录增加删除）时，ZooKeeper 会通知客户端。D：是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口。
zk:redis分布式锁.zip
10-23
分布式锁是一种在分布式系统中实现锁机制的技术，用于在多节点之间协调访问共享资源，确保在高并发环境下数据的一致性和完整性。本压缩包“zk:redis分布式锁.zip”提供了基于Zookeeper（zk）和Redis两种分布式锁实现...
zk分布式锁1
08-03
zk分布式锁1 在分布式系统中，分布式锁是必不可少的组件之一。分布式锁可以确保在分布式环境中，多个节点之间的并发访问被正确地处理。ZooKeeper是一个广泛使用的分布式锁实现方案，本文将对ZooKeeper分布式锁进行...
zk_lock:用zk实现的分布式锁
04-30
1. **临时顺序节点（Ephemeral Sequential Nodes）**：每个试图获取锁的客户端都会在指定的ZNode下创建一个临时顺序节点。这些节点会按照创建的顺序自动排序，从而形成一个队列。 2. **监视（Watch）**：客户端会...
通过zookeeper实现分布式锁
11-13
【Zookeeper实现分布式锁】 Zookeeper 是 Apache ...总之，Zookeeper 的分布式锁机制是基于其强大的一致性特性和事件通知能力实现的，它在分布式系统中扮演着至关重要的角色，帮助协调和管理分布式环境下的并发操作。
ZooKeeper教程、命令、集群
又逢乱世
11-16 8072
zookeeper
基于zookeeper实现分布式锁
一个菜鸡的博客
05-04 2518
如果创建的是永久的节点，那么这个锁永远不会释放，导致死锁；例如子节点列表 为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002，序号为1的客户端监听 序号为0的子节点删除消息，序号为2的监听序号为1的子节点删除消息。客户端获取/lock下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子 节点，如果是则认为获得锁，否则监听刚好在自己之前一位的子节点删除消息，获得子节点变更通 知后重复此步骤直至获得锁；
ZK/zookeeper常规命令 | Watch监控命令的使用 | ACL权限操作 | Four Letter Words四字命令详解 | 配置super超级用户权限 | 总结的很全面，你会喜欢吗
血煞长虹 的专栏
12-08 8545
文章力求用最精简的语言，全面系统的介绍了zk各种命令的使用，这些命令都很重要，可以不用完全熟记，但是不可不知，温故而知新。 get set 是一些常规操作命令，Watch命令用来监听节点的各种变化（java项目实战用的比较多），nc命令有时候也不可或缺，比如dump命令。 全文根据命令的分类：常规、watch监控、Acl权限、nc四字命令，共分为四大章节。可更加目录，快速定位查看。
第1关：创建/删除节点
大家一起入坑
04-21 3326
第1关：创建/删除节点 200 任务要求 参考答案 评论15 任务描述 相关知识 节点类型 持久节点和临时节点 有序节点 创建/删除节点 编程要求 测试说明 任务描述 本关任务：熟悉并掌握四种类型节点的特点，并掌握节点的创建和删除。 相关知识 为了完成本关任务，你需要掌握：1.ZooKeeper服务器开启，2.客服端（zkCli.sh）连接服务器，3.命令行基本操作。 节点类型 ZooKeeper数据模型中的数据单元，称为数据节点（znode）。 ZooK
zookeeper 常用操作
渔夫数据库笔记
10-24 3839
本博客介绍了zookeeper日常运维管理中的一些常用命令
分布式锁3: zk实现分布式锁3 使用临时顺序节点+watch监听实现阻塞锁
健康平安的活着的专栏
01-06 700
接上一篇文章，每个请求要想正常的执行完成，最终都是要创建节点，如果能够避免争抢必然可以提高性能。这里借助于zk的临时序列化节点，实现分布式锁1. 主要修改了构造方法和lock方法：2.并添加了getPreNode获取前置节点的方法。存在的问题就是羊群效应。
ZooKeeper中节点的操作命令（查看、创建、删除节点）
分享式获得也是一种学习的态度
10-27 9306
每个人都有惰性，但不断学习是好好生活的根本，共勉！
Zookeeper实现分布式锁（Zk分布式锁）
最新发布
刘皇叔说Java的博客
03-23 1531
基于zookeeper临时有序节点可以实现的分布式锁。1、zookeeper天生设计定位就是分布式协调，强一致性。锁的模型健壮、简单易用、适合做分布式锁。2、如果获取不到锁，只需要添加一个监听器就可以了，不用一直轮询，性能消耗较小。3、如果有较多的客户端频繁的申请加锁、释放锁，对于zk集群的压力会比较大。
ZK（ZooKeeper）分布式锁实现
fygkchina的专栏
08-30 3476
在平时我们对锁的使用，在针对单个服务，我们可以用 Java 自带的一些锁来实现，资源的顺序访问，但是随着业务的发展，现在基本上公司的服务都是多个，单纯的 Lock或者Synchronize 只能解决单个JVM线程的问题，那么针对于单个服务的 Java 的锁是无法满足我们业务的需要的，为了解决多个服务跨服务访问共享资源，于是就有了分布锁，分布式锁产生的原因就是集群。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值