devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【ZooKeeper学习笔记】

作者：weixin_40725706 | 2024-07-18 08:09:29

赞

踩

【ZooKeeper学习笔记】

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服务

image.png

  1. ./zkServer.sh status查看zookeeper服务运行状态

image.png

  1. ./zkServer.sh restart重启zookeeper服务

image.png

  1. ./zkServer.sh stop关闭zookeeper服务

image.png

  • 客户端命令：
  1. ./zkCli.sh -server ip:port连接指定的zookeeper服务（如连接本地可忽略选项直接使用./zkCli.sh）

image.png

  1. quit退出客户端交互界面

image.png

  1. help查看命令帮助

image.png

  1. ls 目录查看指定目录下的znode节点

image.png

  1. ls -s 目录查看节点详细信息

image.png

  1. create znode [value]创建znode节点（可以携带data）

image.png

  1. create znode -e [value]创建临时节点（会话结束后消失）
  2. create znode -s [value]创建顺序节点

image.png

  1. get znode查看节点携带数据

image.png

  1. set znode value设置节点数据

image.png

  1. delete znode删除指定的znode节点（必须为空）

image.png

  1. deleteall znode删除指定的znode节点及其子节点

image.png

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：

/**
 * 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();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

build：

/**
 * 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;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

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

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

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

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

  • 1
  • 2
  • 3
  • 4
  • 5

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

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

  • 1
  • 2
  • 3
  • 4
  • 5

Case3：创建多级节点

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

  • 1
  • 2
  • 3
  • 4

Case4：创建节点并指定类型

@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");
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
2.3.2.3 删除节点

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

@Test
public void testDelete() throws Exception {
    client.delete().forPath("/app1");
}

  • 1
  • 2
  • 3
  • 4

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

@Test
public void testDeleteAll() throws Exception {
    client.delete().deletingChildrenIfNeeded().forPath("/test");
}

  • 1
  • 2
  • 3
  • 4
2.3.2.4 查询节点

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

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

  • 1
  • 2
  • 3
  • 4
  • 5

Case2：查询节点数据

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

  • 1
  • 2
  • 3
  • 4
  • 5

Case3：查询节点详细信息

@Test
public void testGetData3() throws Exception {
    Stat stat = new Stat();
    client.getData().storingStatIn(stat).forPath("/app2");
    System.out.println(stat);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
2.3.2.5 修改节点

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

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

  • 1
  • 2
  • 3
  • 4
  • 5

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

@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());
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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

代码实现：

@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) {

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

3.2 PathChildren Cache

代码实现：

@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) {

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

3.3 Tree Cache

代码实现：

 @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) {

        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

4. ZooKeeper分布式锁

4.1 ZooKeeper分布式锁原理

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

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

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

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

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

代码如下：

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();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77

5. ZooKeeper集群管理

Leader选举过程：

  • ServerId：服务器ID

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

  • Zxid：数据ID

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

  • 在Leader选举的过程中如果某台ZooKeeper超过了半数选票，则直接当选为Leader
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/844471
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号