【ZooKeeper学习笔记】

米饭好好吃.2024-07-18 17:01

1. ZooKeeper基本概念

Zookeeper官网：https://zookeeper.apache.org/index.html

  • Zookeeper是Apache Hadoop项目中的一个子项目，是一个树形目录服务
  • Zookeeper翻译过来就是动物园管理员，用来管理Hadoop（大象）、Hive（蜜蜂）、Pig（小猪）的管理员，简称zk
  • Zookeeper的本质是一个分布式的、开源的、提供分布式应用程序协调服务的组件
  • Zookeeper提供的主要功能有：
    • 配置管理
    • 分布式锁
    • 集群管理

2. ZooKeeper常用命令

2.1 ZooKeeper数据模型

在正式介绍Zookeeper的常用命令之前，我们先来了解一下Zookeeper的相关数据模型：

  • Zookeeper的是一个树形目录服务，其数据模型与unix文件系统目录树类似，是一个层次化的结构
  • 这里面的每一个节点都被称为ZNode，每个节点上都会保存自己的数据以及元数据信息
  • 节点也可以拥有子节点，同时允许少量数据（1MB）存储在该节点之下
  • 节点类型大致可以分为如下四类：
    • PERSISTENT：持久化节点
    • EPHEMERAL：临时节点 -e
    • PERSISTENT_SEQUENTIAL：持久化顺序节点 -s
    • EPHEMERAL_SEQUENTIAL：临时顺序节点 -e -s

2.2 ZooKeeper常用命令

Zookeeper是一个常见的客户端-服务器模型，我们可以使用命令行或者JavaAPI的方式充当客户端进行访问，其架构如下图所示：

  • 服务端命令：
  1. ./zkServer.sh start启动zookeeper服务
  1. ./zkServer.sh status查看zookeeper服务运行状态
  1. ./zkServer.sh restart重启zookeeper服务
  1. ./zkServer.sh stop关闭zookeeper服务
  • 客户端命令：
  1. ./zkCli.sh -server ip:port连接指定的zookeeper服务（如连接本地可忽略选项直接使用./zkCli.sh）
  1. quit退出客户端交互界面
  1. help查看命令帮助
  1. ls 目录查看指定目录下的znode节点
  1. ls -s 目录查看节点详细信息
  1. create znode [value]创建znode节点（可以携带data）
  1. create znode -e [value]创建临时节点（会话结束后消失）
  2. create znode -s [value]创建顺序节点
  1. get znode查看节点携带数据
  1. set znode value设置节点数据
  1. delete znode删除指定的znode节点（必须为空）
  1. deleteall znode删除指定的znode节点及其子节点

2.3 ZooKeeper的JavaAPI操作

2.3.1 Curator介绍

Curator：是一个Zookeeper的Java客户端库

  • 常见的Zookeeper Java客户端有如下几种：
    1. 原生JavaAPI
    2. ZkClient
    3. Curator
  • Curator的目标就是简化Zookeeper客户端的使用
  • Curator项目最初有Netflix公司研发，后来捐给了Apache基金会，成为顶级项目

Curator官网：http://curator.apache.org/

2.3.2 Curator API操作
2.3.2.1 建立连接

我们可以使用CuratorFrameworkFactory静态工厂类进行创建，可以通过如下两种方式配置：

  1. 使用newClient()方法
  2. 使用build()方法

下面我们就给出对应两种代码的实现方式：
newClient：

java 复制代码 
/**
 * ZooKeeper测试类
 */
public class ZooKeeperTest {

    private CuratorFramework client = null;

    @Before
    public void initByNewClient() {
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181",
                3000,
                3000,
                new ExponentialBackoffRetry(3000, 1));
        this.client = client;
        this.client.start();
    }
}

build：

java 复制代码 
/**
 * ZooKeeper测试类
 */
public class ZooKeeperTest {

    private CuratorFramework client = null;

    @Before
    public void init() {
        CuratorFramework client = CuratorFrameworkFactory
                .builder()
                .connectString("127.0.0.1:2181")
                .sessionTimeoutMs(3000)
                .connectionTimeoutMs(3000)
                .retryPolicy(new ExponentialBackoffRetry(3000, 1))
                .namespace("")
                .build();
        client.start();
        this.client = client;
    }
}

其中各个配置项含义如下：

  • connectString：连接字符串，配置服务器地址，格式为ip:port
  • sessionTimeoutMs：会话超时时间
  • connectionTimeoutMs：连接超时时间
  • retryPolicy：重试策略
  • namespace：设置根目录位置
2.3.2.2 创建节点

创建节点有如下常见的四种方式：
Case1：创建节点（不携带数据）

java 复制代码 
@Test
public void testCreate1() throws Exception {
    String path = client.create().forPath("/app1");
    System.out.println(path);
}

Case2：创建节点（携带数据）

java 复制代码 
@Test
public void testCreate2() throws Exception {
    String path = client.create().forPath("/app2", "curator java api".getBytes());
    System.out.println(path);
}

Case3：创建多级节点

java 复制代码 
@Test
public void testCreate4() throws Exception {
    client.create().creatingParentsIfNeeded().forPath("/test/test1/test2");
}

Case4：创建节点并指定类型

java 复制代码 
@Test
public void testCreate3() throws Exception {
    client.create().withMode(CreateMode.EPHEMERAL).forPath("/app3");
    client.create().withMode(CreateMode.PERSISTENT).forPath("/app4");
    client.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/app5");
    client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/app6");
}
2.3.2.3 删除节点

删除节点有如下常见的两种方式：
Case1：删除节点（不含子节点）

java 复制代码 
@Test
public void testDelete() throws Exception {
    client.delete().forPath("/app1");
}

Case2：删除节点（递归删除子节点）

java 复制代码 
@Test
public void testDeleteAll() throws Exception {
    client.delete().deletingChildrenIfNeeded().forPath("/test");
}
2.3.2.4 查询节点

查询节点有如下常见的三种方式：
Case1：查询子节点信息

java 复制代码 
@Test
public void testGetChildren() throws Exception {
    List<String> childrenList = client.getChildren().forPath("/");
    System.out.println(childrenList);
}

Case2：查询节点数据

java 复制代码 
@Test
public void testGetData() throws Exception {
    byte[] bytes = client.getData().forPath("/app2");
    System.out.println("data: " + new String(bytes));
}

Case3：查询节点详细信息

java 复制代码 
@Test
public void testGetData3() throws Exception {
    Stat stat = new Stat();
    client.getData().storingStatIn(stat).forPath("/app2");
    System.out.println(stat);
}
2.3.2.5 修改节点

修改节点有如下常见的两种方式：
Case1：修改节点数据

java 复制代码 
@Test
public void testSetData() throws Exception {
    Stat stat = client.setData().forPath("/app1", "some data".getBytes());
    System.out.println(stat);
}

Case2：修改节点数据（带有版本号）

java 复制代码 
@Test
public void testSetData2() throws Exception {
    Stat stat = new Stat();
    client.getData().storingStatIn(stat).forPath("/app2");
    int version = stat.getVersion();
    System.out.println(version);
    client.setData().withVersion(version).forPath("/app2", "set with version".getBytes());
}

3. ZooKeeper的事件监听机制

Watcher事件监听机制：

  • ZooKeeper允许用户在指定节点上注册一些Watcher，当一些特定事件发生时，ZooKeeper就会将事件通知给对其感兴趣的客户端，这是ZooKeeper提供分布式协调服务的重要特性
  • ZooKeeper引入了Watcher机制来实现发布 / 订阅功能，能够让多个订阅者同时监听某一个对象，当一个对象状态发生变化时就会通知所有订阅者
  • ZooKeeper提供原生Watcher的方式，但是比较麻烦，因此Curator使用Cache数据结构进行了优化实现监听机制
  • Curator提供了如下三种Cache：
    1. NodeCache：只监听某一个指定的节点变化
    2. PathChildrenCache：监控一个节点的所有子节点
    3. TreeCache：监控整个树上的节点，类似于前两者的组合

3.1 Node Cache

代码实现：

java 复制代码 
@Test
public void testCuratorCache() throws Exception {
    NodeCache cache = new NodeCache(client, "/app1");
    cache.getListenable().addListener(new NodeCacheListener() {
        @Override
        public void nodeChanged() throws Exception {
            System.out.println("监听到节点变化...");
        }
    });
    cache.start();
    while (true) {

    }
}

3.2 PathChildren Cache

代码实现：

java 复制代码 
@Test
public void testPathChildrenCache() throws Exception {
    PathChildrenCache cache = new PathChildrenCache(client, "/app1", true);
    cache.getListenable().addListener(new PathChildrenCacheListener() {
        @Override
        public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
            System.out.println("监听到子节点变化...");
            PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
            if (type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)) {
                System.out.println("监听到子节点数据变化...");
                System.out.println("更新后数据: " + pathChildrenCacheEvent.getData().getData());
            }
        }
    });
    cache.start();
    while (true) {

    }
}

3.3 Tree Cache

代码实现：

java 复制代码 
 @Test
    public void testTreeCache() throws Exception {
        TreeCache cache = new TreeCache(client, "/app1");
        cache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                System.out.println("监听到节点发生变化...");
                System.out.println(treeCacheEvent);
            }
        });
        cache.start();
        while (true) {

        }
    }

4. ZooKeeper分布式锁

4.1 ZooKeeper分布式锁原理

  • 核心思想：当用户获取到锁时就创建节点，使用完锁就删除节点
  1. 每当一个用户想要获取锁时就在/lock节点下创建一个 **临时顺序 **节点
  2. 然后获取/lock节点下的全部子节点，如果发现当前节点编号是最小的，则该节点对应的客户端获取到锁，使用完锁后，删除该节点
  3. 如果发现节点编号不是最小的，则对前一个比自己小的编号节点，并注册事件监听器，监听删除事件
  4. 如果后续发现比自己小的节点被删除，则客户端会接收到来自ZooKeeper的通知，然后再次判断所对应节点编号是否是最小的，重复上述步骤

注意：这里创建临时节点是因为防止获取到锁的客户端宕机了，进而导致锁永远不会被删的情况；这是创建顺序节点是方便编号的排序

Cutator提供了下面五种分布式锁的方式：

  • InterProcessMutex（分布式可重入排他锁）
  • InterProcessSemaphoreMutex（分布式不可重入排他锁）
  • InterProcessReadWriteLock（分布式读写锁）
  • InterProcessMutliLock（将多个锁作为单个实体管理的容器）
  • InterProcessSemaphoreV2（共享信号量）

4.2 分布式锁实战（模拟12306抢票）

代码如下：

java 复制代码 
package org.example;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.TimeUnit;

public class ZooKeeperLockTest {

    private static int tickets = 10; // 票数

    public static void main(String[] args) {
        // 建立连接
        CuratorFramework client = CuratorFrameworkFactory
                .builder()
                .connectString("127.0.0.1:2181")
                .sessionTimeoutMs(3000)
                .connectionTimeoutMs(3000)
                .retryPolicy(new ExponentialBackoffRetry(3000, 1))
                .namespace("")
                .build();
        client.start();
        // 获取分布式锁
        InterProcessMutex lock = new InterProcessMutex(client, "/lock");
        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    boolean hasLock = lock.acquire(3, TimeUnit.SECONDS);
                    if (hasLock && tickets > 0) {
                        // 不断抢票
                        System.out.println("线程" + Thread.currentThread().getName() + "抢到了当前第" + tickets + "张票");
                        tickets--;
                        if (tickets <= 0) {
                            break;
                        }
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    try {
                        lock.release();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }, "携程");

        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    boolean hasLock = lock.acquire(3, TimeUnit.SECONDS);
                    if (hasLock && tickets > 0) {
                        // 不断抢票
                        System.out.println("线程" + Thread.currentThread().getName() + "抢到了当前第" + tickets + "张票");
                        tickets--;
                        if (tickets <= 0) {
                            break;
                        }
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    try {
                        lock.release();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }, "飞猪");
        t1.start();
        t2.start();
    }
}

5. ZooKeeper集群管理

Leader选举过程：

  • ServerId：服务器ID

比如有三台服务器，编号分别是1，2，3。则编号越大在选择算法中的权重就越大

  • Zxid：数据ID

服务器中存放的数据ID越大，值越大说明更新的越频繁，则在选择算法中的权重就越大

  • 在Leader选举的过程中如果某台ZooKeeper超过了半数选票，则直接当选为Leader
相关推荐
eybk3 分钟前
Pytorch+Mumu模拟器+萤石摄像头实现对小孩学习的监控
学习
6.945 分钟前
Scala学习记录 递归调用 练习
开发语言·学习·scala
Aileen_0v014 分钟前
【AI驱动的数据结构：包装类的艺术与科学】
linux·数据结构·人工智能·笔记·网络协议·tcp/ip·whisper
守护者1701 小时前
JAVA学习-练习试用Java实现“使用Arrays.toString方法将数组转换为字符串并打印出来”
java·学习
学会沉淀。2 小时前
Docker学习
java·开发语言·学习
Rinai_R2 小时前
计算机组成原理的学习笔记(7)-- 存储器·其二 容量扩展/多模块存储系统/外存/Cache/虚拟存储器
笔记·物联网·学习
吃着火锅x唱着歌2 小时前
PHP7内核剖析 学习笔记 第四章 内存管理（1）
android·笔记·学习
ragnwang2 小时前
C++ Eigen常见的高级用法 [学习笔记]
c++·笔记·学习
有一个好名字2 小时前
zookeeper分布式锁模拟12306买票
分布式·zookeeper·云原生
胡西风_foxww3 小时前
【es6复习笔记】rest参数（7）
前端·笔记·es6·参数·rest
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明0719个Web前端交互式3D JavaScript框架和库08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO