zookeeper

2022-01-17/2022-01-17
0 评论 111 浏览

1. Zookeeper 入门

1.1 概述

Zookeeper从设计模式角度来理解:是一个基于观察者模式设计的分布式服务管理框架,它负责存储和管理大家都关心的数据,然 后接受观察者的注册,一旦这些数据的状态发生变化,Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。

image-20220116205646836

1.2 特点

image-20220116205719508

  1. Zookeeper:一个领导者(Leader),多个跟随者(Follower)组成的集群。
  2. 集群中只要有半数以上节点存活,Zookeeper集群就能正常服务。所 以Zookeeper适合安装奇数台服务器。
  3. 全局数据一致:每个Server保存一份相同的数据副本,Client无论连接到哪个Server,数据都是一致的。
  4. 更新请求顺序执行,来自同一个Client的更新请求按其发送顺序依次执行。
  5. 数据更新原子性,一次数据更新要么成功,要么失败。
  6. 实时性,在一定时间范围内,Client能读到最新数据。

1.3 数据结构

ZooKeeper 数据模型的结构与 Unix 文件系统很类似,整体上可以看作是一棵树,每个节点称做一个 ZNode。每一个 ZNode 默认能够存储 1MB 的数据,每个 ZNode 都可以通过其路径唯一标识

image-20220116205915536

1.4 应用场景

提供的服务包括:统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、软负载均衡等。

1.4.1 统一命名服务

在分布式环境下,经常需要对应用/服务进行统一命名,便于识别。

例如:IP不容易记住,而域名容易记住。

image-20220116210117232

1.4.2 统一配置管理

  1. 分布式环境下,配置文件同步非常常见。

    • 一般要求一个集群中,所有节点的配置信息是一致的,比如 Kafka 集群。
    • 对配置文件修改后,希望能够快速同步到各个节点上。
  2. 配置管理可交由 ZooKeeper 实现。

  • 可将配置信息写入 ZooKeeper 上的一个 Znode。
  • 各个客户端服务器监听这个 Znode。
  • 一 旦 Znode 中的数据被修改,ZooKeeper 将通知各个客户端服务器。

image-20220116210446438

1.4.3 统一集群管理

  1. 分布式环境中,实时掌握每个节点的状态是必要的。
    • 可根据节点实时状态做出一些调整。
  2. ZooKeeper可以实现实时监控节点状态变化
    • 可将节点信息写入ZooKeeper上的一个ZNode。
    • 监听这个ZNode可获取它的实时状态变化。

image-20220116210745454

1.4.4 服务器动态上下线

image-20220116210819266

1.4.5 软负载均衡

在Zookeeper中记录每台服务器的访问数,让访问数最少的服务器去处理最新的客户端请求

image-20220116210900604

1.5 下载地址

官网:https://zookeeper.apache.com

2. 本地安装

2.1 安装前准备

  1. 安装 JDK
  2. 解压 zookeeper

2.2 配置

  1. 在解压目录下面创建 zkData 存放数据。

  2. conf 下的 zoo_sample.cfg 改名为 zoo.cfg

  3. 编辑 zoo.cfg,配置数据存储地址

    1dataDir=/opt/module/zookeeper/zkData
    

2.3 操作 Zookeeper

启动

1bin/zkServer.sh start

查看进程是否成功

1[atguigu@hadoop102 zookeeper-3.5.7]$ jps
24020 Jps
34001 QuorumPeerMain

查看状态

1[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh status
2ZooKeeper JMX enabled by default
3Using config: /opt/module/zookeeper-3.5.7/bin/../conf/zoo.cfg
4Mode: standalone

standalone 单机启动成功

启动客户端

1bin/zkCli.sh

停止 Zookeeper

1bin/zkServer.sh stop

2.4 配置文件参数

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

  • tickTime = 2000 :通信心跳时间,Zookeeper 服务器与客户端心跳时间,单位毫秒

    • zookeeper服务端通过zookeeper客户端上报心跳来确定zookeeper客户端的存活状态。

    image-20220116212652919

  • initLimit = 10:LF 初始通信时限

    image-20220116213051382

    Leader 和 Follower初始连接时能容忍的最多心跳数(tickTime的数量)

  • syncLimit = 5:LF 同步通信时限image-20220116213203158

    Leader 和 Follower 之间通信时间如果超过 syncLimit * tickTime,Leader 认为 Follwer 死掉,从服务器列表中删除 Follwer。

  • dataDir:保存 Zookeeper 中的数据

    注意:默认的 tmp 目录,容易被 Linux 系统定期删除,所以一般不用默认的 tmp 目录。

  • clientPort = 2181:客户端连接端口,通常不做修改。

3. Zookeeper 集群操作

3.1 集群操作

3.1.1 集群安装

  1. 准备三台机器,hadoop102、hadoop103 和 hadoop104。

  2. 安装 jdk

  3. 安装 zookeeper, 并配置配置文件

  4. 在 zookeeper/zkData 下新建 myid, 添加对应 server 编号(上下左右不能有空行和空格)

    12
    
  5. 查看每台服务器 ip,并修改 /etc/hosts

    110.211.55.6 hadoop102
    210.211.55.7 hadoop103
    310.211.55.8 hadoop104
    
  6. 修改 zoo.cfg 添加如下配置

    1#######################cluster##########################
    2server.2=hadoop102:2888:3888
    3server.3=hadoop103:2888:3888
    4server.4=hadoop104:2888:3888
    

    解读

    1server.A=B:C:D
    
    • A 是一个数字,表示这个是第几号服务器;集群模式下配置一个文件 myid,这个文件在 dataDir 目录下,这个文件里面有一个数据,就是 A 的值,Zookeeper 启动时读取此文件,拿到里面的数据与 zoo.cfg 里面的配置信息比较从而判断到底是哪个 server。
    • B 是这个服务器的地址;
    • C 是这个服务器 Follower 与集群中的 Leader 服务器交换信息的端口;
    • D 是万一集群中的 Leader 服务器挂了,需要一个端口来重新进行选举,选出一个新的 Leader,而这个端口就是用来执行选举时服务器相互通信的端口。
  7. 将以上操作,同步到全部机器,参考 rsync

  8. 修改 每个服务器的 myid 文件,需要与 zoo.cfg 的 server.n 的 n 相同!!!

集群操作

启动

1bin/zkServer.sh start

查看状态

1bin/zkServer.sh start
1[atguigu@hadoop102 zookeeper-3.5.7]# bin/zkServer.sh status
2JMX enabled by default
3Using config: /opt/module/zookeeper-3.5.7/bin/../conf/zoo.cfg
4Mode: follower
5[atguigu@hadoop103 zookeeper-3.5.7]# bin/zkServer.sh status
6JMX enabled by default
7Using config: /opt/module/zookeeper-3.5.7/bin/../conf/zoo.cfg
8Mode: leader

3.1.2 选举机制

3.1.2.1 第一次启动

image-20220116221251205

  • SID:服务器ID。用来唯一标识一台ZooKeeper集群中的机器,每台机器不能重复,和myid一致。
  • ZXID:事务ID。ZXID是一个事务ID,用来标识一次服务器状态的变更。在某一时刻,集群中的每台机器的ZXID值不一定完全一

致,这和ZooKeeper服务器对于客户端“更新请求”的处理逻辑有关。

  • Epoch:每个Leader任期的代号。没有Leader时同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增加
  1. 服务器1启 动,发起一次选举。服务器1投自己一票。此时服务器1票数一票,不够半数以上(3票),选举无法完成,服务器1状态保持为LOOKING;
  2. 服务器2启动,再发起一次选举。服务器1和2分别投自己一票并交换选票信息:此时服务器1发现服务器2的myid比自己目前投票推举的(服务器1) 大,更改选票为推举服务器2。此时服务器1票数0票,服务器2票数2票,没有半数以上结果,选举无法完成,服务器1,2状态保持LOOKING
  3. 服务器3启动,发起一次选举。此时服务器1和2都会更改选票为服务器3。此次投票结果:服务器1为0票,服务器2为0票,服务器3为3票。此时服务器3的票数已经超过半数,服务器3当选Leader。服务器1,2更改状态为FOLLOWING,服务器3更改状态为LEADING;
  4. 服务器4启动,发起一次选举。此时服务器1,2,3已经不是LOOKING状态,不会更改选票信息。交换选票信息结果:服务器3为3票,服务器4为 1票。此时服务器4服从多数,更改选票信息为服务器3,并更改状态为FOLLOWING;
  5. 服务器5启动,同4一样当小弟。

3.1.2.1 非第一次启动

image-20220116221626725

  1. 当ZooKeeper集群中的一台服务器出现以下两种情况之一时,就会开始进入Leader选举:

    • 服务器初始化启动。
    • 服务器运行期间无法和Leader保持连接。
  2. 而当一台机器进入Leader选举流程时,当前集群也可能会处于以下两种状态:

    • 集群中本来就已经存在一个Leader。

      对于第一种已经存在Leader的情况,机器试图去选举Leader时,会被告知当前服务器的Leader信息,对于该机器来说,仅仅需要和Leader机器建立连接,并进行状态同步即可。

    • 集群中确实不存在 leader

      image-20220116221900122

3.1.3 ZK 集群启动停止脚本

在 hadoop102 的/home/atguigu/bin 目录下创建脚本 vim zk.sh

 1#!/bin/bash
 2case $1 in
 3"start"){
 4    for i in hadoop102 hadoop103 hadoop104
 5    do
 6        echo ---------- zookeeper $i 启动 ------------
 7        ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh start"
 8    done
 9};;
10"stop"){
11    for i in hadoop102 hadoop103 hadoop104
12    do
13        echo ---------- zookeeper $i 停止 ------------
14        ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh stop"
15    done
16};;
17"status"){
18    for i in hadoop102 hadoop103 hadoop104
19    do
20    	echo ---------- zookeeper $i 状态 ------------
21    	ssh $i "/opt/module/zookeeper-3.5.7/bin/zkServer.sh status"
22    done
23};;
24esac

3.2 客户端命令行操作

3.2.1 命令行语法

命令基本语法 功能描述
help 显示所有操作命令
ls path 使用 ls 命令来查看当前 znode 的子节点 [可监听] -w 监听子节点变化-s 附加次级消息
create 普通创建-s 含有序列-e 临时(重启或者超时消失)
get path 获得节点的值 [可监听] -w 监听节点内容变化-s 附加次级信息
set 设置节点的具体值
stat 查看节点状态
delete 删除节点
deleteall 递归删除节点

启动客户端

1bin/zkCli.sh -server hadoop102:2181

显示所有操作命令

1[zk: hadoop102:2181(CONNECTED) 1] help

3.2.2 node 节点数据信息

查看当前 znode 中所包含的内容

1[zk: hadoop102:2181(CONNECTED) 0] ls /
2[zookeeper]

查看当前节点的详细数据

 1[zk: hadoop102:2181(CONNECTED) 5] ls -s /
 2[zookeeper]cZxid = 0x0
 3ctime = Thu Jan 01 08:00:00 CST 1970
 4mZxid = 0x0
 5mtime = Thu Jan 01 08:00:00 CST 1970
 6pZxid = 0x0
 7cversion = -1
 8dataVersion = 0
 9aclVersion = 0
10ephemeralOwner = 0x0
11dataLength = 0
12numChildren = 1
  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。

  1. dataLength:znode 的数据长度
  2. numChildren:znode 子节点数量

3.2.3 节点类型

image-20220116224246848

分为 持久/短暂/有序号/无序号

持久(Persistent):客户端和服务器端断开连接后,创建的节点不删除

短暂(Ephemeral):客户端和服务器端断开连接后,创建的节点自己删除

顺序标识说明

创建znode时设置顺序标识,znode名称后会附加一个值,顺序号是一个单调递增的计数器,由父节点维护

注意:在分布式系统中,顺序号可以被用于为所有的事件进行全局排序,这样客户端可以通过顺序号推断事件的顺序

持久化目录节点

客户端与Zookeeper断开连接后,该节点依旧存在

持久化顺序编号目录节点

客户端与Zookeeper断开连接后,该节点依旧存在,只是Zookeeper给该节点名称进行顺序编号

临时目录节点

客户端与Zookeeper断开连接后,该节点被删除

临时顺序编号目录节点

客户端与 Zookeeper 断开连接后 , 该 节 点 被 删 除 , 只 是Zookeeper给该节点名称进行顺序编号。


1)分别创建2个普通节点(永久节点 + 不带序号)

1[zk: localhost:2181(CONNECTED) 3] create /sanguo "diaochan"
2Created /sanguo
3[zk: localhost:2181(CONNECTED) 4] create /sanguo/shuguo "liubei"
4Created /sanguo/shuguo

注意:创建节点时,要赋值

2)获得节点的值

 1[zk: localhost:2181(CONNECTED) 5] get -s /sanguo
 2diaochan
 3cZxid = 0x100000003
 4ctime = Wed Aug 29 00:03:23 CST 2018
 5mZxid = 0x100000003
 6mtime = Wed Aug 29 00:03:23 CST 2018
 7pZxid = 0x100000004
 8cversion = 1
 9dataVersion = 0
10aclVersion = 0
11ephemeralOwner = 0x0
12dataLength = 7
13numChildren = 1
14[zk: localhost:2181(CONNECTED) 6] get -s /sanguo/shuguo
15liubei
16cZxid = 0x100000004
17ctime = Wed Aug 29 00:04:35 CST 2018
18mZxid = 0x100000004
19mtime = Wed Aug 29 00:04:35 CST 2018
20pZxid = 0x100000004
21cversion = 0
22dataVersion = 0
23aclVersion = 0
24ephemeralOwner = 0x0
25dataLength = 6
26numChildren = 0

3)创建带序号的节点(永久节点 + 带序号)

(1)先创建一个普通的根节点/sanguo/weiguo

1[zk: localhost:2181(CONNECTED) 1] create /sanguo/weiguo "caocao"
2Created /sanguo/weiguo

(2)创建带序号的节点

1[zk: localhost:2181(CONNECTED) 2] create -s /sanguo/weiguo/zhangliao "zhangliao"
2Created /sanguo/weiguo/zhangliao0000000000
3[zk: localhost:2181(CONNECTED) 3] create -s /sanguo/weiguo/zhangliao "zhangliao"
4Created /sanguo/weiguo/zhangliao0000000001
5[zk: localhost:2181(CONNECTED) 4] create -s /sanguo/weiguo/xuchu "xuchu"
6Created /sanguo/weiguo/xuchu0000000002

如果原来没有序号节点,序号从 0 开始依次递增。如果原节点下已有 2 个节点,则再排序时从 2 开始,以此类推。

4)创建短暂节点(短暂节点 + 不带序号 or 带序号)

(1)创建短暂的不带序号的节点

1[zk: localhost:2181(CONNECTED) 7] create -e /sanguo/wuguo "zhouyu"
2Created /sanguo/wuguo

(2)创建短暂的带序号的节点

1[zk: localhost:2181(CONNECTED) 2] create -e -s /sanguo/wuguo "zhouyu"
2Created /sanguo/wuguo0000000001

(3)在当前客户端是能查看到的

1[zk: localhost:2181(CONNECTED) 3] ls /sanguo 
2[wuguo, wuguo0000000001, shuguo]

(4)退出当前客户端然后再重启客户端

1[zk: localhost:2181(CONNECTED) 12] quit
2[atguigu@hadoop104 zookeeper-3.5.7]$ bin/zkCli.sh

(5)再次查看根目录下短暂节点已经删除

1[zk: localhost:2181(CONNECTED) 0] ls /sanguo
2[shuguo]

5)修改节点数据值

1[zk: localhost:2181(CONNECTED) 6] set /sanguo/weiguo "simayi"

3.2.4 监听器原理

客户端注册监听它关心的目录节点,当目录节点发生变化(数据改变、节点删除、子目录节点增加删除)时,ZooKeeper 会通知客户端。监听机制保证 ZooKeeper 保存的任何的数据的任何改变都能快速的响应到监听了该节点的应用程序。

image-20220116225155679

监听器原理详解

  1. 首先要有一个main()线程
  2. 在main线程中创建Zookeeper客户端,这时就会创建两个线程,一个负责网络连接通信(connet),一个负责监听(listener)。
  3. 通过connect线程将注册的监听事件发送给Zookeeper。
  4. 在Zookeeper的注册监听器列表中将注册的监听事件添加到列表中。
  5. Zookeeper监听到有数据或路径变化,就会将这个消息发送给listener线程。
  6. listener线程内部调用了process()方法。

常见的监听器

  • 监听节点数据的变化:get path [watch]
  • 监听子节点增减的变化:ls path [watch]

节点的值变化监听

  1. 在 hadoop104 主机上注册监听 /sanguo 节点数据变化

    1[zk: localhost:2181(CONNECTED) 26] get -w /sanguo
    
  2. 在 hadoop103 主机上修改/sanguo 节点的数据

    1[zk: localhost:2181(CONNECTED) 1] set /sanguo "xisi"
    
  3. 观察 hadoop104 主机收到数据变化的监听

    1WATCHER::
    2WatchedEvent state:SyncConnected type:NodeDataChanged 
    3path:/sanguo
    

    注意:在hadoop103再多次修改/sanguo的值,hadoop104上不会再收到监听。因为注册一次,只能监听一次。想再次监听,需要再次注册。

节点的子节点变化监听(路径变化)

  1. 在 hadoop104 主机上注册监听/sanguo 节点的子节点变化

    1[zk: localhost:2181(CONNECTED) 1] ls -w /sanguo
    2[shuguo, weiguo]
    
  2. 在 hadoop103 主机/sanguo 节点上创建子节点

    1[zk: localhost:2181(CONNECTED) 2] create /sanguo/jin "simayi"
    2Created /sanguo/jin
    
  3. 观察 hadoop104 主机收到子节点变化的监听

    1WATCHER::
    2WatchedEvent state:SyncConnected type:NodeChildrenChanged 
    3path:/sanguo
    

    注意:节点的路径变化,也是注册一次,生效一次。想多次生效,就需要多次注册。

    3.2.5 节点删除与查看

    1. 删除节点

      1[zk: localhost:2181(CONNECTED) 4] delete /sanguo/jin
      
    2. 递归删除节点

      1[zk: localhost:2181(CONNECTED) 15] deleteall /sanguo/shuguo
      
    3. 查看节点状态

       1[zk: localhost:2181(CONNECTED) 17] stat /sanguo
       2cZxid = 0x100000003
       3ctime = Wed Aug 29 00:03:23 CST 2018
       4mZxid = 0x100000011
       5mtime = Wed Aug 29 00:21:23 CST 2018
       6pZxid = 0x100000014
       7cversion = 9
       8dataVersion = 1
       9aclVersion = 0
      10ephemeralOwner = 0x0
      11dataLength = 4
      12numChildren = 1
      

3.3 客户端 API 操作

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

3.3.1 IDEA 环境搭建

  1. 创建工程:zookeeper

  2. 添加 pom 文件

     1<dependencies>
     2    <dependency>
     3        <groupId>junit</groupId>
     4        <artifactId>junit</artifactId>
     5        <version>RELEASE</version>
     6    </dependency>
     7    <dependency>
     8        <groupId>org.apache.logging.log4j</groupId>
     9        <artifactId>log4j-core</artifactId>
    10        <version>2.8.2</version>
    11    </dependency>
    12    <dependency>
    13        <groupId>org.apache.zookeeper</groupId>
    14        <artifactId>zookeeper</artifactId>
    15        <version>3.5.7</version>
    16    </dependency>
    17</dependencies>
    
  3. 创建包名 com.atguigu.zk

  4. 创建类名称 zkClient

3.3.2 创建 Zookeeper 客户端

 1private static String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
 2private static int sessionTimeout = 2000;
 3private ZooKeeper zkClient = null;
 4
 5@Before
 6public void init() throws Exception {
 7    zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
 8        @Override
 9        public void process(WatchedEvent watchedEvent) {
10            // 收到事件通知后的回调函数(用户的业务逻辑)
11            System.out.println(watchedEvent.getType() + "--" + watchedEvent.getPath());
12            // 再次启动监听
13            try {
14                List<String> children = zkClient.getChildren("/", true);
15                for (String child : children) {
16                    System.out.println(child);
17                }
18            } catch (Exception e) {
19                e.printStackTrace();
20            }
21        }
22    });
23}

3.3.3 创建子节点

1// 创建子节点
2public void create() throws Exception {
3// 参数 1:要创建的节点的路径; 参数 2:节点数据 ; 参数 3:节点权限 ;参数 4:节点的类型
4    String nodeCreated = zkClient.create("/atguigu",
5            "shuaige".getBytes(), Ids.OPEN_ACL_UNSAFE,
6            CreateMode.PERSISTENT);
7}

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

1// 获取子节点
2public void getChildren() throws Exception {
3    List<String> children = zkClient.getChildren("/", true);
4    for (String child : children) {
5        System.out.println(child);
6    }
7    // 延时阻塞
8    Thread.sleep(Long.MAX_VALUE);
9}
  1. 在 IDEA 控制台上看到如下节点:

    1zookeeper
    2sanguo
    3atguigu
    
  2. 在 hadoop102 的客户端上创建再创建一个节点/atguigu1,观察 IDEA 控制台

    1[zk: localhost:2181(CONNECTED) 3] create /atguigu1 "atguigu1"
    
  3. 在 hadoop102 的客户端上删除节点/atguigu1,观察 IDEA 控制台

    1[zk: localhost:2181(CONNECTED) 4] delete /atguigu1
    

3.3.5 判断 Znode 是否存在

1// 判断 znode 是否存在
2public void exist() throws Exception {
3	Stat stat = zkClient.exists("/atguigu", false);
4	System.out.println(stat == null ? "not exist" : "exist");
5}

3.4 客户端想服务端写数据流程

写入请求直接发送给 Leader 节点

image-20220116234856276

写入请求发送给 follower

image-20220116234935239

4. 服务器动态上下线监听案例

4.1 需求

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

4.2 需求分析

image-20220116235137579

4.3 具体实现

  1. 先在集群上创建/servers 节点

    1[zk: localhost:2181(CONNECTED) 10] create /servers "servers"
    2Created /servers
    
  2. 在 Idea 中创建包名:com.atguigu.zkcase1

  3. 服务器端向 Zookeeper 注册代码

     1private static String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
     2private static int sessionTimeout = 2000;
     3private ZooKeeper zk = null;
     4private String parentNode = "/servers";
     5
     6// 创建到 zk 的客户端连接
     7public void getConnect() throws IOException {
     8    zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
     9        @Override
    10        public void process(WatchedEvent event) {
    11        }
    12    });
    13}
    14
    15// 注册服务器
    16public void registServer(String hostname) throws Exception {
    17    String create = zk.create(parentNode + "/server",
    18            hostname.getBytes(), Ids.OPEN_ACL_UNSAFE,
    19            CreateMode.EPHEMERAL_SEQUENTIAL);
    20    System.out.println(hostname + " is online " + create);
    21}
    22
    23// 业务功能
    24public void business(String hostname) throws Exception {
    25    System.out.println(hostname + " is working ...");
    26    Thread.sleep(Long.MAX_VALUE);
    27}
    28
    29public static void main(String[] args) throws Exception {
    30    // 1 获取 zk 连接
    31    DistributeServer server = new DistributeServer();
    32    server.getConnect();
    33    // 2 利用 zk 连接注册服务器信息
    34    server.registServer(args[0]);
    35    // 3 启动业务功能
    36    server.business(args[0]);
    37}
    
  4. 客户端代码

     1public class DistributeClient {
     2    private static String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
     3    private static int sessionTimeout = 2000;
     4    private ZooKeeper zk = null;
     5    private String parentNode = "/servers";
     6
     7    // 创建到 zk 的客户端连接
     8    public void getConnect() throws IOException {
     9        zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
    10            @Override
    11            public void process(WatchedEvent event) {
    12                // 再次启动监听
    13                try {
    14                    getServerList();
    15                } catch (Exception e) {
    16                    e.printStackTrace();
    17                }
    18            }
    19        });
    20    }
    21
    22    // 获取服务器列表信息
    23    public void getServerList() throws Exception {
    24        // 1 获取服务器子节点信息,并且对父节点进行监听
    25        List<String> children = zk.getChildren(parentNode, true);
    26        // 2 存储服务器信息列表
    27        ArrayList<String> servers = new ArrayList<>();
    28        // 3 遍历所有节点,获取节点中的主机名称信息
    29        for (String child : children) {
    30            byte[] data = zk.getData(parentNode + "/" + child, false, null);
    31            servers.add(new String(data));
    32        }
    33        // 4 打印服务器列表信息
    34        System.out.println(servers);
    35    }
    36
    37    // 业务功能
    38    public void business() throws Exception {
    39        System.out.println("client is working ...");
    40        Thread.sleep(Long.MAX_VALUE);
    41    }
    42
    43    public static void main(String[] args) throws Exception {
    44        // 1 获取 zk 连接
    45        DistributeClient client = new DistributeClient();
    46        client.getConnect();
    47        // 2 获取 servers 的子节点信息,从中获取服务器信息列表
    48        client.getServerList();
    49        // 3 业务进程启动
    50        client.business();
    51    }
    52}
    

4.4 测试

在 Linux 命令行上操作增加减少服务器

  1. 启动 DistributeClient 客户端

  2. 在 hadoop102 上 zk 的客户端/servers 目录上创建临时带序号节点

    1create -e -s /servers/hadoop102 "hadoop102"
    2create -e -s /servers/hadoop103 "hadoop103"
    
  3. 观察 Idea 控制台变化

    1[hadoop102, hadoop103]
    
  4. 执行删除操作

    1delete /servers/hadoop1020000000000
    
  5. 观察 Idea 控制台变化

    1[hadoop103]
    

5. ZooKeeper 分布式锁案例

什么叫做分布式锁呢?

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

image-20220117003653547

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

分布式锁实现

 1public class DistributedLock {
 2    // zookeeper server 列表
 3    private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
 4    // 超时时间
 5    private int sessionTimeout = 2000;
 6    private ZooKeeper zk;
 7    private String rootNode = "locks";
 8    private String subNode = "seq-";
 9    // 当前 client 等待的子节点
10    private String waitPath;
11    // ZooKeeper 连接
12    private CountDownLatch connectLatch = new CountDownLatch(1);
13    // ZooKeeper 节点等待
14    private CountDownLatch waitLatch = new CountDownLatch(1);
15    // 当前 client 创建的子节点
16    private String currentNode;
17
18    // 和 zk 服务建立连接,并创建根节点
19    public DistributedLock() throws IOException, InterruptedException, KeeperException {
20        zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
21            @Override
22            public void process(WatchedEvent event) {
23                // 连接建立时, 打开 latch, 唤醒 wait 在该 latch 上的线程
24                if (event.getState() == Event.KeeperState.SyncConnected) {
25                    connectLatch.countDown();
26                }
27                // 发生了 waitPath 的删除事件
28                if (event.getType() == Event.EventType.NodeDeleted && event.getPath().equals(waitPath)) {
29                    waitLatch.countDown();
30                }
31            }
32        });
33        // 等待连接建立
34        connectLatch.await();
35        //获取根节点状态
36        Stat stat = zk.exists("/" + rootNode, false);
37        //如果根节点不存在,则创建根节点,根节点类型为永久节点
38        if (stat == null) {
39            System.out.println("根节点不存在");
40            zk.create("/" + rootNode, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
41        }
42    }
43
44    // 加锁方法
45    public void zkLock() {
46        try {
47            //在根节点下创建临时顺序节点,返回值为创建的节点路径
48            currentNode = zk.create("/" + rootNode + "/" + subNode,
49                    null, ZooDefs.Ids.OPEN_ACL_UNSAFE,
50                    CreateMode.EPHEMERAL_SEQUENTIAL);
51            // wait 一小会, 让结果更清晰一些
52            Thread.sleep(10);
53            // 注意, 没有必要监听"/locks"的子节点的变化情况
54            List<String> childrenNodes = zk.getChildren("/" + rootNode, false);
55            // 列表中只有一个子节点, 那肯定就是 currentNode , 说明 client 获得锁
56            if (childrenNodes.size() == 1) {
57                return;
58            } else {
59                //对根节点下的所有临时顺序节点进行从小到大排序
60                Collections.sort(childrenNodes);
61                //当前节点名称
62                String thisNode = currentNode.substring(("/" + rootNode + "/").length());
63                //获取当前节点的位置
64                int index = childrenNodes.indexOf(thisNode);
65                if (index == -1) {
66                    System.out.println("数据异常");
67                } else if (index == 0) {
68                    // index == 0, 说明 thisNode 在列表中最小, 当前client 获得锁
69                    return;
70                } else {
71                    // 获得排名比 currentNode 前 1 位的节点
72                    this.waitPath = "/" + rootNode + "/" + childrenNodes.get(index - 1);
73                    // 在 waitPath 上注册监听器, 当 waitPath 被删除时, zookeeper 会回调监听器的 process 方法
74                    zk.getData(waitPath, true, new Stat());
75                    //进入等待锁状态
76                    waitLatch.await();
77                    return;
78                }
79            }
80        } catch (KeeperException e) {
81            e.printStackTrace();
82        } catch (InterruptedException e) {
83            e.printStackTrace();
84        }
85    }
86
87    // 解锁方法
88    public void zkUnlock() {
89        try {
90            zk.delete(this.currentNode, -1);
91        } catch (InterruptedException | KeeperException e) {
92            e.printStackTrace();
93        }
94    }
95}

分布式锁测试

创建两个线程

 1public class DistributedLockTest {
 2    public static void main(String[] args) throws InterruptedException, IOException, KeeperException {
 3        // 创建分布式锁 1
 4        final DistributedLock lock1 = new DistributedLock();
 5        // 创建分布式锁 2
 6        final DistributedLock lock2 = new DistributedLock();
 7        new Thread(new Runnable() {
 8            @Override
 9            public void run() {
10                // 获取锁对象
11                try {
12                    lock1.zkLock();
13                    System.out.println("线程 1 获取锁");
14                    Thread.sleep(5 * 1000);
15                    lock1.zkUnlock();
16                    System.out.println("线程 1 释放锁");
17                } catch (Exception e) {
18                    e.printStackTrace();
19                }
20            }
21        }).start();
22        new Thread(new Runnable() {
23            @Override
24            public void run() {
25                // 获取锁对象
26                try {
27                    lock2.zkLock();
28                    System.out.println("线程 2 获取锁");
29                    Thread.sleep(5 * 1000);
30                    lock2.zkUnlock();
31                    System.out.println("线程 2 释放锁");
32                } catch (Exception e) {
33                    e.printStackTrace();
34                }
35            }
36        }).start();
37    }
38}

观察控制台变化

1线程 1 获取锁
2线程 1 释放锁
3线程 2 获取锁
4线程 2 释放锁

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

原生的 Java API 开发存在的问题

  1. 会话连接是异步的,需要自己去处理。比如使用 CountDownLatch
  2. Watch 需要重复注册,不然就不能生效
  3. 开发的复杂性还是比较高的
  4. 不支持多节点删除和创建。需要自己去递归

Curator 是一个专门解决分布式锁的框架,解决了原生 JavaAPI 开发分布式遇到的问题。

详情请查看官方文档:https://curator.apache.org/index.html

Curator 案例实操

添加依赖

 1<dependency>
 2    <groupId>org.apache.curator</groupId>
 3    <artifactId>curator-framework</artifactId>
 4    <version>4.3.0</version>
 5</dependency>
 6<dependency>
 7    <groupId>org.apache.curator</groupId>
 8    <artifactId>curator-recipes</artifactId>
 9    <version>4.3.0</version>
10</dependency>
11<dependency>
12    <groupId>org.apache.curator</groupId>
13    <artifactId>curator-client</artifactId>
14    <version>4.3.0</version>
15</dependency>

代码实现

 1public class CuratorLockTest {
 2    private String rootNode = "/locks";
 3    // zookeeper server 列表
 4    private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
 5    // connection 超时时间
 6    private int connectionTimeout = 2000;
 7    // session 超时时间
 8    private int sessionTimeout = 2000;
 9
10    public static void main(String[] args) {
11        new CuratorLockTest().test();
12    }
13
14    // 测试
15    private void test() {
16        // 创建分布式锁 1
17        final InterProcessLock lock1 = new InterProcessMutex(getCuratorFramework(), rootNode);
18        // 创建分布式锁 2
19        final InterProcessLock lock2 = new InterProcessMutex(getCuratorFramework(), rootNode);
20        new Thread(new Runnable() {
21            @Override
22            public void run() {
23                // 获取锁对象
24                try {
25                    lock1.acquire();
26                    System.out.println("线程 1 获取锁");
27                    // 测试锁重入
28                    lock1.acquire();
29                    System.out.println("线程 1 再次获取锁");
30                    Thread.sleep(5 * 1000);
31                    lock1.release();
32                    System.out.println("线程 1 释放锁");
33                    lock1.release();
34                    System.out.println("线程 1 再次释放锁");
35                } catch (Exception e) {
36                    e.printStackTrace();
37                }
38            }
39        }).start();
40        new Thread(new Runnable() {
41            @Override
42            public void run() {
43                // 获取锁对象
44                try {
45                    lock2.acquire();
46                    System.out.println("线程 2 获取锁");
47                    // 测试锁重入
48                    lock2.acquire();
49                    System.out.println("线程 2 再次获取锁");
50                    Thread.sleep(5 * 1000);
51                    lock2.release();
52                    System.out.println("线程 2 释放锁");
53                    lock2.release();
54                    System.out.println("线程 2 再次释放锁");
55                } catch (Exception e) {
56                    e.printStackTrace();
57                }
58            }
59        }).start();
60    }
61
62    // 分布式锁初始化
63    public CuratorFramework getCuratorFramework() {
64        //重试策略,初试时间 3 秒,重试 3 次
65        RetryPolicy policy = new ExponentialBackoffRetry(3000, 3);
66        //通过工厂创建 Curator
67        CuratorFramework client =
68                CuratorFrameworkFactory.builder()
69                        .connectString(connectString)
70                        .connectionTimeoutMs(connectionTimeout)
71                        .sessionTimeoutMs(sessionTimeout)
72                        .retryPolicy(policy).build();
73        //开启连接
74        client.start();
75        System.out.println("zookeeper 初始化完成...");
76        return client;
77    }
78}

控制台变化

1线程 1 获取锁
2线程 1 再次获取锁
3线程 1 释放锁
4线程 1 再次释放锁
5线程 2 获取锁
6线程 2 再次获取锁
7线程 2 释放锁
8线程 2 再次释放锁

6. 面试真题

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

安装奇数台。

生产经验:

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

服务器台数多:好处,提高可靠性;坏处:提高通信延时

评论
发表评论
       
       
取消