Zookeeper学习笔记一

1.初始 Zookeeper

1.1 Zookeeper 概念

  1. Zookeeper 是 Apache Hadoop 项目下的一个子项目,是一个树形目录服务
  2. Zookeeper 翻译过来就是 动物园管理员,他是用来管 Hadoop(大象)、Hive(蜜蜂)、Pig(小 猪)的管理员。简称zk
  3. Zookeeper 是一个分布式的、开源的分布式应用程序的协调服务。
  4. Zookeeper 提供的主要功能包括:
    1. 配置管理
    2. 分布式锁
    3. 集群管理

2. Zookeeper 安装与配置

3.Zookeepwe 命令操作

3.1 Zookeeper 数据模型

  1. ZooKeeper 是一个树形目录服务,其数据模型和Unix的文件系统目录树很类似,拥有一个层次化结构。
  2. 这里面的每一个节点都被称为: ZNode,每个节点上都会保存自己的数据和节点信息。(有点像B树)
  3. 节点可以拥有子节点,同时也允许少量(1MB)数据存储在该节点之下。
  4. 节点可以分为四大类:
    1. PERSISTENT 持久化节点(默认)
    2. EPHEMERAL 临时节点 :-e
    3. PERSISTENT_SEQUENTIAL 持久化顺序节点 :-s
    4. EPHEMERAL_SEQUENTIAL 临时顺序节点 :-es

3.2 Zookeeper 服务端常用命令

	启动 ZooKeeper 服务: ./zkServer.sh start
	查看 ZooKeeper 服务状态: ./zkServer.sh status
	停止 ZooKeeper 服务: ./zkServer.sh stop 
	重启 ZooKeeper 服务: ./zkServer.sh restart 

3.3 Zookeeper 客户端常用命令

# 1.连接Zookeeper 服务端
	./zkCli.sh –server ip:port
# 2.断开连接
	quit
# 3.查看命令帮助
	help
# 4.显示指定目录下节点
	ls 目录
# 5.创建节点
	create /节点path value
# 6.获取节点值
	get /节点path
# 7.设置节点值
	set /节点path value
# 8.删除单个节点
	delete /节点path
# 9.删除带有子节点的节点
	deleteall /节点path
# 10.创建临时节点
	create -e /节点path value
# 11.创建顺序节点
	create -s /节点path value
# 12.查询节点详细信息
	ls -s /节点path


查询节点详细信息

  • czxid:节点被创建的事务ID

  • ctime: 创建时间

  • mzxid: 最后一次被更新的事务ID

  • mtime: 修改时间

  • pzxid:子节点列表最后一次被更新的事务ID

  • cversion:子节点的版本号

  • dataversion:数据版本号

  • aclversion:权限版本号

  • ephemeralOwner:用于临时节点,代表临时节点的事务ID,如果为持久节点则为0

  • dataLength:节点存储的数据的长度

  • numChildren:当前节点的子节点个数

4. Zookeeper JavaAPI 操作

4.1 Curator

Curator 介绍

  • Curator 是 Apache Zookeeper 的 Java 客户端库
  • 常见的Zookeeper Java API:
    • 原生 Java API
    • ZkClient
    • Curator
  • Curator 项目的目标是简化 Zookeeper 客户端的使用
  • Curator 最初是 Netfix 研发的,后来捐献了 Apache 基金会,目前是 Apache 的顶级项目
  • 官网:http://curator.apache.org/

4.2 Curator API 常用操作

4.2.1 建立连接

private  CuratorFramework client;
@Test
public void testConnext(){

        //重试策略
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        /**
         * 1.连接字符串. zk server 地址和端口 "xxx.xxx.xxx.xxx:2181"
         * 2. 会话超时时间 单位ms
         * 3. 连接超时时间 单位ms
         * 4.重试策略
         */
            //1.第一种方式
//         client = CuratorFrameworkFactory.newClient("xxx.xxx.xxx.xxx:2181",
//                60 * 1000, 15 * 1000, retryPolicy);
    
        //2.第二种方式
        client = CuratorFrameworkFactory.builder().connectString("xxx.xxx.xxx.xxx:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy).namespace("itheima").build();
        //开启连接
        client.start();
    }
//释放资源
@After
    public void close(){
        if(client != null){
            client.close();
        }
    }

4.2.2 添加节点

1.基本创建

 @Test
public void testCreate() throws Exception {
    //1.基本创建
    String path = client.create().forPath("/app2");
    System.out.println(path);
}

2.创建节点,带有数据

@Test
public void testCreate1() throws Exception {
    //2.创建节点,带有数据
    String path = client.create().forPath("/app2","hehe".getBytes());
    System.out.println(path);
}

3.设置节点类型

@Test
public void testCreate2() throws Exception {
    //3.设置节点的类型(临时节点)
    //默认类型: 持久化
    String path = client.create().withMode(CreateMode.EPHEMERAL).forPath("/appe1");
    System.out.println(path);
}

4.创建多级节点 /app1/p1

@Test
public void testCreate3() throws Exception {
    //4. 创建多级节点 /app1/p1
    //creatingParentsIfNeeded() 如果父节点不存在就创建
    String path = client.create().creatingParentsIfNeeded().forPath("/app4/p1");
    System.out.println(path);
}

4.2.3 删除节点

1.删除单个节点

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

2.删除带有子字节的节点

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

3.强制删除

@Test
public void  delete2() throws Exception {
    client.delete().guaranteed().forPath("/app2");
}

4.回调

@Test
public void  delete3() throws Exception {
    client.delete().guaranteed().inBackground(new BackgroundCallback() {
        @Override
        public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
            System.out.println("我被删除了");
            System.out.println(curatorEvent);
        }
    }).forPath("/app2");
}

4.2.4 修改节点

1.修改数据

@Test
public void  testSet() throws Exception {
    client.setData().forPath("/app2","zz".getBytes());
}

2.根据版本修改

@Test
public void  testSet2() throws Exception {
    Stat status = new Stat();
    client.getData().storingStatIn(status).forPath("/app2");
    int version = status.getVersion();
    System.out.println(version);
    client.setData().withVersion(version).forPath("/app2","haha".getBytes());
}

4.2.5 查询节点

1.查询数据 : get

@Test
public void testCet1() throws Exception {
    //1.查询数据: get
    byte[] data = client.getData().forPath("/app1");
    System.out.println(new String(data));

}

2.查询子节点: ls

@Test
public void testCet2() throws Exception {
    //2.查询子节点: ls
    final List<String> path = client.getChildren().forPath("/");
    System.out.println(path);
}

3.查询节点状态信息: ls -s

@Test
public void testCet3() throws Exception {
    //3. 查询节点状态信息: ls -s
    Stat status = new Stat();
    System.out.println(status);
    client.getData().storingStatIn(status).forPath("/app1");
    System.out.println(status);
}

4.2.6 Watch事件监听

Curator API 常用操作 **- Watch ** 事件监听

  • ZooKeeper 允许用户在指定节点上注册一些Watcher,并且在一些特定事件触发的时候,ZooKeeper 服务端会将事件通知到感兴趣的客户端上去,该机制是 ZooKeeper 实现分布式协调服务的重要特性。

  • ZooKeeper 中引入了Watcher机制来实现了发布/订阅功能能,能够让多个订阅者同时监听某一个对象,当一个对象自身状态变化时,会通知所有订阅者。

  • ZooKeeper 原生支持通过注册Watcher来进行事件监听,但是其使用并不是特别方便需要开发人员自己反复注册Watcher,比较繁琐。

  • Curator引入了 Cache 来实现对 ZooKeeper 服务端事件的监听。

  • ZooKeeper提供了三种Watcher:

    • NodeCache : 只是监听某一个特定的节点

    • PathChildrenCache : 监控一个ZNode的子节点.

    • TreeCache : 可以监控整个树上的所有节点,类似于PathChildrenCache和NodeCache的组合

1.对某一个节点进行监听

 @Test
public void testNodeCache() throws Exception {
    //1. 创建NodeCache对象
    NodeCache nodeCache = new NodeCache(client, "/app2");
    //2.注册监听
    nodeCache.getListenable().addListener(new NodeCacheListener() {
        @Override
        public void nodeChanged() throws Exception {
            System.out.println("节点变化了~");

            final byte[] data = nodeCache.getCurrentData().getData();
            System.out.println(new String(data));
        }
    });
    //3.开启监听.如果设置为true,则开启监听是,加载数据
    nodeCache.start(true);
    while(true){

    }
}

2.监听一个ZNode的子节点

 @Test
public void testPathChildrenCache() throws Exception {
    //1.创建监听对象
    final PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/app2", true);
    //2.绑定监听器
    pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
        @Override
        public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
            System.out.println("子节点变化了");
            System.out.println(pathChildrenCacheEvent);
            //监听子节点的数据变更,并且拿到变更后的数据
            final PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
            //2.判断类型是否是update
            if (type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)){
                System.out.println("数据变了!!");
                final byte[] data = pathChildrenCacheEvent.getData().getData();
                System.out.println(new String(data));
            }
        }
    });
    pathChildrenCache.start();

    while(true){

    }
}

3.可以监控整个树上的所有节点,类似于PathChildrenCache和NodeCache的组合

 @Test
public void testTreeCache() throws Exception {
    //1.创建监听器
    TreeCache treeCache = new TreeCache(client,"/app2");
    //2.注册监听
    treeCache.getListenable().addListener(new TreeCacheListener() {
        @Override
        public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
            System.out.println("节点发生改变了");
            System.out.println(treeCacheEvent);
        }
    });
    treeCache.start();

    while(true){

    }
}

4.3 分布式锁

1. 分布式锁

  • 在我们进行单机应用开发,涉及并发同步的时候,我们往往采用synchronized或者Lock的方式来解决多线程间的代码同步问题,这时多线程的运行都是在同一个JVM之下,没有任何问题。

  • 但当我们的应用是分布式集群工作的情况下,属于多JVM下的工作环境,跨JVM之间已经无法通过多线程的锁解决同步问题。

  • 那么就需要一种更加高级的锁机制,来处理种跨机器的进程之间的数据同步问题——这就是分布式锁。

2.ZooKeeper* 分布式锁原理

  • 核心思想:当客户端要获取锁,则创建节点,使用完锁,则删除该节点。
  1. 客户端获取锁时,在lock节点下创建临时顺序节点。

  2. 然后获取lock下面的所有子节点,客户端获取到所有的子节点之后,如果发现自己创建的子节点序号最小,那么就认为该客户端获取到了锁。使用完锁后,将该节点删除。

  3. 如果发现自己创建的节点并非lock所有子节点中最小的,说明自己还没有获取到锁,此时客户端需要找到比自己小的那个节点,同时对其注册事件监听器,监听删除事件。

  4. 如果发现比自己小的那个节点被删除,则客户端的Watcher会收到相应通知,此时再次判断自己创建的节点是否是lock子节点中序号最小的,如果是则获取到了锁,如果不是则重复以上步骤继续获取到比自己小的一个节点 并注册监听。

4.4 模拟12306售票案例

Ticket12306

public class Ticket12306 implements Runnable{
    //数据库的票数
    private int tickets = 100;
    private InterProcessMutex lock;
    private CuratorFramework client;
    public Ticket12306(){
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        client = CuratorFrameworkFactory.builder().connectString("xxx.xxx.xxx.xxx:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy).build();
        //开启连接
        client.start();
        lock = new InterProcessMutex(client,"/lock");
    }
    @Override
    public void run() {
        while(true){
            //1. 获取锁
            try {
                lock.acquire(3, TimeUnit.SECONDS);
                if(tickets > 0){
                    System.out.println(Thread.currentThread() + " : " + tickets);
                    tickets--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

LockTest

public class LockTest {
    public static void main(String[] args) {
        Ticket12306 ticket12306 = new Ticket12306();
        //创建客户端
        Thread t1 = new Thread(ticket12306, "携程");
        Thread t2 = new Thread(ticket12306, "飞猪");
        t1.start();
        t2.start();
    }
}

5.Zookeeper 集群 搭建

6. Zookeeper 核心理论

Zookeeper 集群角色

在ZooKeeper集群服中务中有三个角色:

  • Leader 领导者 :

    1. 处理事务请求

    2. 集群内部各服务器的调度者

  • Follower 跟随者 :

    1. 处理客户端非事务请求,转发事务请求给Leader服务器

    2. 参与Leader选举投票

  • Observer 观察者:

    1. 处理客户端非事务请求,转发事务请求给Leader服务器

7.问题

  1. zookeeper端口与Tomcat端口冲突需要改变用户端口
# 在zookeeper启动的时候,看打印信息显示会启动jetty,会使用到端口8080,如果安装了Tomcat就会发生冲突,导致Zookeeper 启动失败,所以要在配置文件zoo.cfg指定admin.serverPort=8089
  1. 防火墙问题
# 防火墙问题可能导致Java API 连接Zookeeper 连接超时,需要关闭防火墙 service iptables stop,我使用的阿里云服务器,还是把2181 端口放开

参考资料
黑马程序员Zookeeper

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值