Zookeeper学习笔记

已于 2022-08-19 00:17:05 修改
阅读量460 收藏 1
点赞数
分类专栏： zookeeper 文章标签： java-zookeeper zookeeper 学习
于 2022-08-18 23:32:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70577348/article/details/126403828
版权

Zookeeper

前言

关于源码部分，静等工作之后再学习。本文是参考尚硅谷大海哥的讲义来进行学习笔记的编辑的。

一、Zookeeper入门

1.1 概述

Zookeeper 是一个开源的分布式的，为分布式框架提供协调服务的Apache 项目。
在这里插入图片描述
在这里插入图片描述

1.2 特点

在这里插入图片描述

1.3 数据结构

在这里插入图片描述

1.4 应用场景

提供的服务包括：统一命名服务、统一配置服务、统一集群管理、服务器节点动态上下线、软负载均衡等。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.5 下载

1.官网

2.下载截图
在这里插入图片描述
3.如果要下载旧版本，操作如下图。
在这里插入图片描述
4.选择3.5.7
在这里插入图片描述
5.下载 Linux环境安装的 tar包
在这里插入图片描述

二、Zookeeper本地安装

2.1 安装及配置

  1. mkdir /opt/software和 mkdir /opt/module前面一个是解压目录，后面一个是安装目录
  2. 检查系统中是否有jdk======java -version
  3. 将压缩包拷贝到 /opt/software 目录下
  4. 解压到指定目录 tar -zxvf apache-zookeeper-3.5.7-bin-tar-ge -C /opt/module
  5. 通常我们需要修改名称，修改为 mv apache-zookeeper-3.5.7 -bin/zookeeper-3.5.7
  6. 将 /opt/module/zookeeper-3.5.7/conf 这个路径下的 zoo_sample.cfg修改为 zoo.cfg
    操作： mv zoo_sample.cfg zoo.cfg
  7. 打开zoo.cfg文件，修改dataDir路径，因为数据默认是存放到临时路径下的，临时路径/tmp这个会被定时清理，所以我们需要自己在 /opt/module/zookeeper-3.5.7/ 这个目录上创建zkData文件夹。然后在zoo.cfg文件中修改如下内容：

dataDir=/opt/module/zookeeper-3.5.7/zkData

2.2 启动与关闭客户端

  1. 启动客户端 bin/zkServer.sh start
    在这里插入图片描述
  2. 查看进程是否启动
    在这里插入图片描述
  3. 查看状态 bin/zkServer.sh status
    在这里插入图片描述
  4. 启动客户端 bin/zkCli.sh

在这里插入图片描述

  1. 退出客户端 quit

在这里插入图片描述

  1. 停止Zookeeper bin/zkServer.sh stop
    在这里插入图片描述

2.2 配置参数详解

Zookeeper中的配置文件zoo.cfg中参数含义解读如下：

  • 1）tickTime = 2000：通信心跳时间，Zookeeper服务器与客户端心跳时间，单位毫秒。
    在这里插入图片描述
  • 2）initLimit = 10：LF初始通信时限
    在这里插入图片描述
  • 3）syncLimit = 5：LF同步通信时限
    在这里插入图片描述
  • 4）dataDir：保存Zookeeper中的数据
    注意：默认的tmp目录，容易被Linux系统定期删除，所以一般不用默认的tmp目录。
  • 5）clientPort = 2181：客户端连接端口，通常不做修改。

三、Zookeeper集群操作

3.1 集群操作

1）集群规划
在hadoop102、 hadoop103和 hadoop104三个 节点上 都部署 Zookeeper。
思考：如果是10台服务器，需要部署多少台 Zookeeper？

2）解压安装
（1） 在 hadoop102解压 Zookeeper安装包到 /opt/module/目录下
在这里插入图片描述
（2）修改 apache-zookeeper-3.5.7-bin名称为 zookeeper-3.5.7
在这里插入图片描述

3）配置服务器编号
（1）在 /opt/module/zookeeper-3.5.7/这个目录下创建 zkData
在这里插入图片描述
（2）在 /opt/module/zookeeper-3.5.7/zkData目录下创建一个 myid的文件
在这里插入图片描述
在文件中添加与server对应的编号 （注意：上下不要有空行，左右不要有空格）
注意添加 myid文件，一定要在 Linux里面创建，在 notepad++里面很可能乱码
（3）将前面的步骤在另外两个虚拟机中重复进行：

最终结果呈现：
编号3:192.168.249.103
编号4:192.168.249.104
编号5:192.168.249.105

4）配置zoo.cfg文件
（1）重命名 /opt/module/zookeeper-3.5.7/conf这个目录下的 zoo_sample.cfg为 zoo.cfg
在这里插入图片描述
在这里插入图片描述

  • 增加如下配置

##########cluster#############
server.2=192.168.249.103:2888:3888
server.3=192.168.249.104:2888:3888
server.4=192.168.249.105:2888:3888

配置参数解读：
在这里插入图片描述
（4）在另外两台虚拟机中进行同样的配置
注意：笔记中的handoop是老师课件中的，这是本机的hostname，实际中我这里显示的是虚拟机的IP地址。

5）集群操作
在这里插入图片描述
在这里插入图片描述

3.2 选举机制（面试重点）

在这里插入图片描述
在这里插入图片描述

3.3 ZK集群启动停止脚本

在上一步中我们创建了zookeeper集群，但是每次启动是不是都要进入zookeeper安装目录中去进行执行启动，停止，查看状态脚本呢。如果有100台呢，所以我们可以去设置一个批量启动脚本来进行集群批量启动等状态。

  1. 在根目录下的bin目录中创建一个脚本文件，zk.sh
    在这里插入图片描述
  2. 编辑 vim zk.sh

具体参考脚本代码如下：

#!/bin/bash

case $1 in
"start"){
        for i in 192.168.249.103 192.168.249.104 192.168.249.105
        do
                echo -------------  zookeeper $i 启动 ------------
                sshpass -p "atguigu@"   ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh start"
        done
}
;;
"stop"){

        for i in 192.168.249.103 192.168.249.104 192.168.249.105
        do
                echo -------------  zookeeper $i 停止 ------------
                sshpass -p "atguigu@"   ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh stop"

        done
}
;;
"status"){
        for i in 192.168.249.103 192.168.249.104 192.168.249.105
        do
                echo -------------  zookeeper $i 状态 ------------
                sshpass -p "atguigu@"   ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh status"
    done
}
;;
esac

当然也可以参考网上其他人的：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  1. 编辑脚本完成之后，具体启动、停止、查看状态命令如下：

编辑完后，进行脚本执行权限 chmod 777 zk.sh
启动脚本：zk.sh start
停止脚本：zk.sh stop

3.4 客户端操作

3.4.1 命令行操作

在这里插入图片描述

3.4.2 znode节点数据信息

在这里插入图片描述
（1 ）czxid 创建节点的事务 zxid
每次修改ZooKeeper状态都会 产生一个 ZooKeeper事务 ID。事务 ID是 ZooKeeper中所有修改总的次序。每次修改都有唯一的 zxid，如果 zxid1小于 zxid2，那么 zxid1在 zxid2之前发生。
（2 ）ctime znode被创建的毫秒数（从 1970年开始）
（3 ）mzxid znode最后更新的事务 zxid
（4 ）mtime znode最后修改的毫秒数（从 1970年开始）
（5 ）pZxid znode最后更新的子节点 zxid
（6）cversion：znode 子节点变化号，znode 子节点修改次数
（7）dataversion：znode 数据变化号
（8）aclVersion：znode 访问控制列表的变化号
（9）ephemeralOwner：如果是临时节点，这个是znode 拥有者的session id。如果不是临时节点则是0。
（10）dataLength：znode 的数据长度
（11）numChildren：znode 子节点数量

3.4.3 节点类型（持久/短暂/有序/无序）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.4.4 监听器原理

客户端注册监听它关心的目录节点，当目录节点发生变化（数据改变、节点删除、子目录节点增加删除）时，ZooKeeper 会通知客户端。监听机制保证ZooKeeper 保存的任何的数据的任何改变都能快速的响应到监听了该节点的应用程序。
在这里插入图片描述
在这里插入图片描述

3.4.5 节点删除与查看

在这里插入图片描述

3.5 客户端API操作

前提：保证 hadoop102、 hadoop103、 hadoop104服务器上 Zookeeper集群服务端启动。

3.5.1 IDEA环境搭建

1）创建一个工程：zookeeper
2）添加pom文件

<dependencies>
     <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.5.7</version>
        </dependency>
  </dependencies>

3）拷贝log4j.properties文件到项目根目录
需要在项目的src/main/resources目录下，新建一个文件，命名为 log4j.properties，在文件中填入。

log4j.rootLogger=INFO, stdout  
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n  
log4j.appender.logfile=org.apache.log4j.FileAppender  
log4j.appender.logfile.File=target/spring.log  
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

4）创建包名com.atguigu.zk
5）创建类名称zkClient

3.5.2 创建 ZooKeeper客户端

在这里插入图片描述
在这里插入图片描述

3.5.3 创建子节点

在这里插入图片描述

3.5.4 获取子节点并监听节点变化

在这里插入图片描述

3.5.5 判断 Znode是否存在

在这里插入图片描述
在这里插入图片描述

下面是我自己参考老师上课所讲的内容写的代码，仅供参考：
@Before – 表示在任意使用@Test注解标注的public void方法执行之前执行

package com.atguigu.zk;

public class zkClient {

    private String connectString = "192.168.249.103:2181,192.168.249.104:2181,192.168.249.105:2181";

    private int sessionTimeout = 2000000;

    private ZooKeeper zkClient;

    //    @Test
    @Before
    public void init() throws IOException {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {


                //如果没有下面代码，那么就只监听一次， 如有，则实时监听

                  //监听代码
//                System.out.println("----------------------------------");
//                //监听实时变化
//                //监听根目录下
//                List<String> children = null;
//                try {
//                    children = zkClient.getChildren("/", true);
//
//                    for (String child: children) {
//                        System.out.println(child);
//                    }
//                    System.out.println("----------------------------------");
//
//                } catch (KeeperException e) {
//                    e.printStackTrace();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }

            }
        });
    }


    @Test
    public void create() throws InterruptedException, KeeperException {


        //参数1：要创建的节点的路径；
        //参数2：节点数据
        //参数3：节点权限
        //参数4：节点的类型
        String nodeCreated = zkClient.create("/atguigu", "ss.avi".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }


    //监听实时变化
    @Test
    public void getChildren() throws InterruptedException, KeeperException {
        //true  开启监听
        //此处为true,监听使用的是init()方法中的new Watcher()监听
        List<String> children = zkClient.getChildren("/", true);

        for (String child : children) {
            System.out.println(child);
        }

        //设置延时(否则马上就执行完，再创建一个，控制台监听不到)
        Thread.sleep(Long.MAX_VALUE);
    }


    @Test
    public void exist() throws InterruptedException, KeeperException {
        Stat stat = zkClient.exists("/atguigu", false);
        System.out.println(stat == null ? "not exist" : "exist");

    }
}

启动客户端报错：org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss for /atguigu(这个bug我弄了2个小时，实在无可奈何，哎！只能放上大招了)

网上查找解决办法 ：
经过调试发现 private static final int sessionTimeout = 1000 中设置的sessionTimeout值太小，应增大此值，问题解决。
解释：sessionTimeout是会话超时时间，也就是当一个zookeeper超过该时间没有心跳，则认为该节点故障。所以，如果此值小于zookeeper的创建时间，则当zookeeper还未来得及创建连接，会话时间已到，因此抛出异常认为该节点故障。
在这里插入图片描述

3.6 客户端向服务端写数据流程

在这里插入图片描述

四、服务器动态上下线监听案例

4.1 需求

某分布式系统中，主节点可以有多台，可以动态上下线，任意一台客户端都能实时感知到主节点服务器的上下线。

4.2 需求分析

在这里插入图片描述

4.3 代码实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

自己编写的服务器端代码实现如下：

package com.atguigu.case1;

/**服务器
 * @author wystart
 * @create 2022-08-17 12:41
 */
public class DistributeServer {


    private String connectString = "192.168.249.103:2181,192.168.249.104:2181,192.168.249.105:2181";
    private int sessionTimeout = 2000000;
    private ZooKeeper zooKeeper;


    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {

        DistributeServer server = new DistributeServer();
        //1.获取zk连接，将服务器和zk集群相连接
        server.getConnect();

        //2.注册服务器到zk集群，注册其实就是创建/servers下路径，即创建节点
        server.regist(args[0]);//在启动的时候通过args传入主机名称


        //3.启动业务逻辑（让进程不要一下子就执行完了，让其睡觉）
        server.business();


    }

    private void business() throws InterruptedException {
        Thread.sleep(Long.MAX_VALUE);

    }

    //将主机名称传入，进行注册（启动一台，注册一台）
    private void regist(String hostname) throws InterruptedException, KeeperException {

        //创建临时带序号的节点
        String create = zooKeeper.create("/servers/" + hostname, hostname.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);


        System.out.println(hostname + "  is online");


    }


    //创建到 zk 的客户端连接
    public void getConnect() throws IOException {

        zooKeeper = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {

            }
        });

    }


}

客户端代码实现：

package com.atguigu.case1;
/**
 * 客户端
 *
 * @author wystart
 * @create 2022-08-17 13:10
 */
public class DistributeClient {


    private ZooKeeper zooKeeper;
    private String connectString = "192.168.249.103:2181,192.168.249.104:2181,192.168.249.105:2181";
    private int sessionTimeout = 2000000;

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        DistributeClient client = new DistributeClient();


        //1.获取zk连接
        client.getConnect();

        //2.监听/servers下面子节点的增加和删除
        client.getServerList();

        //3.业务逻辑（睡觉）
        client.business();


    }

    private void business() throws InterruptedException {

        Thread.sleep(Long.MAX_VALUE);
    }

    //获取服务器列表信息
    private void getServerList() throws InterruptedException, KeeperException {

        //监听/servers这个节点下数据的变化，如果参数写的是true，表示使用的是getConnect()：初始化里面的监听器，否则需要我们自己创建
        List<String> children = zooKeeper.getChildren("/servers", true);


        ArrayList<String> servers = new ArrayList<>();

        //遍历子节点，取出主机名称，判断是否上下线，然后封装到一个list集合中进行打印
        for (String child : children) {


            //获取子节点对应的值
            byte[] data = zooKeeper.getData("/servers/" + child, false, null);

            //加到集合中
            servers.add(new String(data));
        }

        //打印
        System.out.println(servers);

    }

    private void getConnect() throws IOException {

        zooKeeper = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {


                //如果这里没有加，则只会监听一次（因为只注册了一次），在初始化这里加了之后，实时监听
                try {
                    getServerList();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (KeeperException e) {
                    e.printStackTrace();
                }

            }
        });


    }


}

4.4 测试

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述在这里插入图片描述

五、Zookeeper分布式锁案例

5.1 需求

什么叫做分布式锁呢？

比如说 “进程 1” 在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程1"用完该资源以后就将锁释放掉，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了 分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。

5.2 需求分析

在这里插入图片描述

5.3 原生Zookeeper实现分布式锁案例

5.3.1 代码具体实现

DistributedLock 

package com.atguigu.case2;
/**
 * @author wystart
 * @create 2022-08-17 23:19
 */
public class DistributedLock {

    private final String connectString = "192.168.249.103:2181,192.168.249.104:2181,192.168.249.105:2181";
    private final int sessionTimeOut = 200000;
    private final ZooKeeper zk;

    private CountDownLatch countLatch = new CountDownLatch(1);
    //等待前一步骤完成，下一步骤才进行执行
    private CountDownLatch waitLatch = new CountDownLatch(1);

    private String currentMode;
    //前一个节点的路径
    private String waitPath;


    public DistributedLock() throws IOException, InterruptedException, KeeperException {

        // 获取连接
        zk = new ZooKeeper(connectString, sessionTimeOut, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {

                //监听器中判断释放的时机
                //connectLatch  如果连接上zk 可以释放
                //判断监听的事件的状态是否是连接
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    //如果是，释放掉
                    countLatch.countDown();
                }

                //waitLatch 需要释放
                //如果节点的删除而且节点路径时前一个节点路径，证明前一个节点已经下线
                if (watchedEvent.getType()== Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)){
                    waitLatch.countDown();
                }
            }
        });


        //  等待zk正常连接后，才往下执行程序，使得代码健壮性更强
        countLatch.await();

        // 判断根节点/locks是否存在
        Stat stat = zk.exists("/locks", false);

        if (stat == null) {
            // 创建一下根节点
            zk.create("/locks", "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }


    }


    // 对zk加锁    其实就是在/locks 目录下创建临时有序的节点
    public void zkLock() {
        //创建对应的临时有序号的节点
        try {
            currentMode = zk.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

            // wait 一小会，让结果更清晰一些
            Thread.sleep(10);

            //判断创建的节点是否是最小的序号节点，如果是获取到锁，如果不是，监听它序号前一个节点
            List<String> children = zk.getChildren("/locks", false);


            //如果children 只有一个值，那就直接获取锁，如果有多个节点，需要判断，谁最小
            if (children.size() == 1) {

                //直接返回，获取到锁
                return;
            } else {

                //如果有多个节点，需要取出来进行比较
                //对节点排序
                Collections.sort(children);

                // 获取节点名称 seq-00000000
                String thisNode = currentMode.substring("/locks/".length());
                // 通过seq-00000000获取该节点在children集合的位置
                int index = children.indexOf(thisNode);

                //判断
                if (index == -1) {
                    System.out.println("数据异常");
                } else if (index == 0) {
                    //就一个节点,可以获取锁了
                    return;
                } else {
                    //如果不止一个节点，就需要进行监听了
                    //waitPath（前一个节点的路径）：需要监听，它前一个节点的变化
                    waitPath = "/locks/" + children.get(index - 1);
                    zk.getData(waitPath,true,new Stat());

                    // 等待监听
                    waitLatch.await();

                    return;
                }



            }


        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }


    // 解锁  其实就是删除 /locks目录下的临时节点
    public void unZkLock() {

        //删除节点
        try {
            zk.delete(this.currentMode,-1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }

    }

}

5.3.2 测试

package com.atguigu.case2;
/**
 * @author wystart
 * @create 2022-08-17 23:20
 */
public class DistributedLockTest {

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        final DistributedLock lock1 = new DistributedLock();
        final DistributedLock lock2 = new DistributedLock();


        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    lock1.zkLock();
                    System.out.println("线程1 启动 ， 获取到锁");

                    lock1.unZkLock();
                    System.out.println("线程1  释放锁");

                    Thread.sleep(5 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


            }
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    lock2.zkLock();
                    System.out.println("线程2 启动 ， 获取到锁");

                    lock2.unZkLock();
                    System.out.println("线程2  释放锁");

                    Thread.sleep(5 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


            }
        }).start();


    }


}

在这里插入图片描述
在这里插入图片描述

5.4 Curator框架实现分布式锁案例

1 ）原生的 Java API开发存在的问题
（1） 会话连接是异步的，需要自己去处理。比如使用 CountDownLatch
（2） Watch需要重复注册，不然就不能生效
（3）开发的复杂性还是比较高的
（4）不支持多节点删除和创建。需要自己去递归
2） Curator是一个专门解决分布式锁的框架，解决了原生 Java API开发分布式遇到的问题。
详情请查看官方文档： 官方文档点这

5.4.1 具体代码实现

添加依赖：

<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.3.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.3.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-client</artifactId>
            <version>4.3.0</version>
        </dependency>

代码如下：

package com.atguigu.case3;
/**
 * @author wystart
 * @create 2022-08-18 12:41
 */
public class CuratorLockTest {


    public static void main(String[] args) {


        //创建分布式锁1
        InterProcessMutex lock1 = new InterProcessMutex(getCuratorFrameWork(), "/locks");
        //创建分布式锁2
        InterProcessMutex lock2 = new InterProcessMutex(getCuratorFrameWork(), "/locks");

        new Thread(new Runnable() {
            @Override
            public void run() {
                //获取锁对象
                try {
                    lock1.acquire();
                    System.out.println("线程1 获取到锁");

                    //测试锁重入
                    lock1.acquire();
                    System.out.println("线程1 再次获取到锁");

                    Thread.sleep(5 * 1000);

                    lock1.release();
                    System.out.println("线程1 释放锁");

                    lock1.release();
                    System.out.println("线程1 再次释放锁");

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();



        new Thread(new Runnable() {
            @Override
            public void run() {
                //获取锁对象
                try {
                    lock2.acquire();
                    System.out.println("线程2 获取到锁");

                    //测试锁重入
                    lock2.acquire();
                    System.out.println("线程2 再次获取到锁");

                    Thread.sleep(5 * 1000);

                    lock2.release();
                    System.out.println("线程2 释放锁");

                    lock2.release();
                    System.out.println("线程2 再次释放锁");

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();



    }

    //分布式锁初始化
    private static CuratorFramework getCuratorFrameWork() {
        //重试策略
        //失败之后重试的时间和次数
        ExponentialBackoffRetry retry = new ExponentialBackoffRetry(200000, 3);

        //创建客户端（通过客户端创建Curator）
        //retryPolicy 失败之后重试次数和时间
        CuratorFramework client = CuratorFrameworkFactory.builder().connectString("192.168.249.103:2181,192.168.249.104:2181,192.168.249.105:2181")
                .sessionTimeoutMs(200000)
                .connectionTimeoutMs(200000)
                .retryPolicy(retry)
                .build();


        //客户端启动（开启连接）
        client.start();
        System.out.println("zookeeper 客户端启动成功");

        //返回客户端
        return client;

    }

}

在这里插入图片描述

六、企业面试真题（面试重点）

6.1 选举机制

半数机制 ，超过半数的投票通过，即通过。
（1）第一次启动选举规则:
投票过半数时，服务器 id大的胜出
（2）第二次启动选举规则
①EPOCH大的直接胜出（leader任期时的版本号）
②EPOCH相同，事务 id大的胜出
③事务id相同，服务器 id大的胜出

6.2 生产集群安装多少zk合适

安装奇数台。
生产经验：

  • 10台 服务器： 3台 zk
  • 20台 服务器： 5台 zk
  • 100台 服务器： 11台 zk
  • 200台 服务器： 11台 zk

服务器台数多：好处，提高可靠性；坏处：提高通信延时。

6.3 常用命令

ls、 get、 create、 delete

注意：源码部分留待以后进行学习完善。

总结

本篇文章仅仅是对Zookeeper进行了基础操作，对源码的解析还有待进行完善和学习。

Golden State Warrior
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zookeeper（尚硅谷b站课程笔记2021）
qq_24095055的博客
05-22 767
文章目录第 1 章 Zookeeper 入门1.1 概述1.2 特点1.3 数据结构1.4 应用场景1.5 下载地址第 2 章 Zookeeper 本地安装第 3 章 Zookeeper 集群操作3.1 集群操作3.1.1 集群安装3.1.2 选举机制（面试重点）3.1.3 ZK 集群启动停止脚本3.2 客户端命令行操作3.2.1 命令行语法3.2.2 znode 节点数据信息3.2.3 节点类型（持久/短暂/有序号/无序号）3.2.4 监听器原理1）节点的值变化监听2）节点的子节点变化监听（路径变化）3.
Zookeeper常用操作命令
qq_42264264的博客
05-23 913
在zkEnv.sh 将下面的WARN手动改为INFO export ZOO_LOG4J_PROP=WARN,ROLLINGFILE。[-s] [-e]：-s 和 -e 都是可选的，-s 代表顺序节点， -e 代表临时节点，注意其中 -s 和 -e。在log4j.properties中加入 zookeeper.log.threshold INFO。zookeeper.root.logger INFO,ROLLINGFILE 重启zk即可。可以同时使用的，并且临时节点不能再创建子节点。
zookeeper常用命令以及权限控制
weixin_45163291的博客
07-20 898
ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。ZooKeeper的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功能稳定的系统提供给用户。增加zookeeper权限账户，为ZooKeeper配置相应的访问权限。在通常情况下，zookeeper允许未经授权的访问。将ACL权限信息加密。
Zookeeper节点下的子节点数过多，rmr删除报错
u014170770的博客
08-09 1532
修改ZKCli.sh，加上"-Djute.maxbuffer=49107800"$JAVA "-Dzookeeper.log.dir=${ZOO_LOG_DIR}" "-Dzookeeper.root.logger=${ZOO_LOG4J_PROP}" \ "-Djute.maxbuffer=49107800" -cp "$CLASSPATH" $CLIENT_JVMFLAGS $JVMFLAGS \ org.apache.zookeeper.ZooKeeperMain "$@" 改完后rmr ...
删除redis缓存或清空注册服务
dmlcq的博客
06-18 1628
我在我的window电脑上安装了zookeeper用来作为dubbo服务的注册中心。 我启动了zookeeper服务。 通过jps 和 zkCli.cmd 查看zookeeper启动正常。 dubbo服务也已经注册到zookeeper上面了，并且启动成功 启动次数太多，重启过太多次，IP和端口也改过很多次 那么问题来了：每次再启动时，就会报错，提示以...
zookeeper学习笔记
01-18
zookeeper学习笔记
Zookeeper学习笔记.docx
03-27
Zookeeper学习笔记
ZooKeeper学习笔记
03-14
java ZooKeeper学习笔记\ZooKeeper原理、运用
Zookeeper学习笔记.pdf
09-10
ZooKeeper是一种为分布式应用所设计的高可用、高性能且一致的开源协调服务，它提供了一项基本服务：**分布式锁服务**。由于ZooKeeper的开源特性，后来我们的开发者在分布式锁的基础上，摸索了出了其他的使用方法：**...
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
Zookeeper 介绍及搭建
weixin_45881674的博客
07-27 1605
Zookeeper 介绍及搭建
zookeeper客户端命令详解
heihei36的专栏
04-27 2万+
zookeeper客户端命令详解 简介 查阅了网上相关资料，介绍zookeeper客户端命令并不是非常全面，大多数都是简单介绍ls、get、set、delete、stat这几个简单命令的，下面我把help中的所有命令简单介绍一下以供参考。 首先说明一下如何打开zk服务端和客户端，cd到zk安装目录下，运行bin/zkServer.shstart即可启动服务端，运行bin/zkCli.sh –
Zookeeper 入门与基本命令
闲人笔记
07-14 1万+
Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。它能提供基于类似于文件系统的目录节点树方式的数据存储，但是 Zookeeper 并不是用来专门存储数据的，它的作用主要是用来维护和监控你存储的数据的状态变化。通过监控这些数据状态的变化，从而可以达
(3)zookeeper常用命令及节点属性介绍
没头脑遇到不高兴
09-10 5785
本节介绍 上节搭建完成了一个zookeeper集群后，本节将介绍一下zookeeper的一些客户端命令的使用方法。 zookeeper命令 首先启动zookeeper服务端，然后通过zkCli.sh脚本启动客户端。 [root@zookeeper zookeeper-3.4.6]# ./bin/zkCli.sh Connecting to localhost:2181 2018-09-0...
ZooKeeper系列之二:Zookeeper常用命令
热门推荐
xiaolang85的专栏
10-25 32万+
ZooKeeper服务命令:      在准备好相应的配置之后，可以直接通过zkServer.sh 这个脚本进行服务的相关操作 1. 启动ZK服务:       sh bin/zkServer.sh start 2. 查看ZK服务状态: sh bin/zkServer.sh status 3. 停止ZK服务:       sh bin/zkServer.sh stop 4. 重启ZK服务:
zookeeper常用命令(三)
这个名字想了很久
09-27 1万+
原文地址，转载请注明出处：&amp;amp;nbsp;https://blog.csdn.net/qq_34021712/article/details/82871697&amp;amp;nbsp;&amp;amp;nbsp; &amp;amp;nbsp;&amp;amp;nbsp;©王赛超&amp;amp;nbsp; 上一篇博客讲了如何安装单机zk和集群搭建，本章来学习zookeeper常用命令。 常用shell脚本操作命令 shell脚本在zooke
【Apache ZooKeeper】命令行zkCli.sh使用指南
云原生社区博客分享
09-12 13万+
apache ZooKeeper命令行下命令使用。
zookeeper集群的配置及使用
逐波与逆流
07-20 1万+
hadoop,spark,kafka交流群：459898801 zookeeper
zookeeper学习
最新发布
10-10
学习 ZooKeeper 可以帮助你理解分布式系统的原理和实现。 首先，你可以了解 ZooKeeper 的基本概念和架构。ZooKeeper 采用了主从架构，由一个 Leader 和多个 Follower 组成。Leader 负责处理客户端请求，Follower ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值