ZooKeeper学习笔记

什么是zk？

Zookeeper 是一个分布式的、开源的分布式应用程序的协调服务。

Zookeeper 提供的主要功能包括：

        配置管理

        分布式锁

        集群管理

Zookeeper 数据模型

ZooKeeper 是 一个树形目录 服务 , 其数据模型 和 Unix 的文件系统目录树很类似，拥有一个 层次化结构。

这里面的每一个节点都被称为： ZNode ，每个节点上都会保存自己的数据和节点信息。

节点可以拥有子节点，同时也允许少量（1MB ）数据存储在该节点之下。

节点可以分为四大类：

PERSISTENT 持久化节点

EPHEMERAL 临时节点 ： -e

PERSISTENT_SEQUENTIAL 持久化顺序节点 ： -s

EPHEMERAL_SEQUENTIAL 临时顺序节点  ： - es

Zookeeper 服务端常用命令

启动 ZooKeeper 服务: ./zkServer.sh start

查看 ZooKeeper 服务状态: ./zkServer.sh status

停止 ZooKeeper 服务: ./zkServer.sh stop 

重启 ZooKeeper 服务: ./zkServer.sh restart

Curator API 常用操作

建立连接

@Before
    public void testConnection(){
        //1.第一种连接方式
        //连接超时后的重试策略
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
        /*CuratorFramework client = CuratorFrameworkFactory.newClient("121.199.32.186:2181", 5000, 5000,
                retryPolicy);
        client.start();*/

        //2.第二种连接方式
        client = CuratorFrameworkFactory.builder().connectString("121.199.32.186:2181").sessionTimeoutMs(5000).
                connectionTimeoutMs(5000).retryPolicy(retryPolicy).namespace("dyb").build();
        client.start();
    }

添加节点

/**
     * 创建节点，默认持久化，未添加数据
     * @throws Exception
     */
    @Test
    public void testCreate1() throws Exception {
        String path = client.create().forPath("/app1");
        System.out.println(path);
    }

/**
     * 创建节点，默认持久化，添加数据
     * @throws Exception
     */
    @Test
    public void testCreate2() throws Exception {
        String path = client.create().forPath("/app2","你好".getBytes());
        System.out.println(path);
    }

/**
     * 创建临时节点
     * @throws Exception
     */
    @Test
    public void testCreate3() throws Exception {
        String path = client.create().withMode(CreateMode.EPHEMERAL).forPath("/app3");
        System.out.println(path);
    }

/**
     * 创建持久有序节点
     * @throws Exception
     */
    @Test
    public void testCreate4() throws Exception {
        String path = client.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/app4");
        System.out.println(path);
    }

/**
     * 创建多级节点
     * @throws Exception
     */
    @Test
    public void testCreate5() throws Exception {
        String path = client.create().creatingParentsIfNeeded().forPath("/app5/p1");
        System.out.println(path);
    }

删除节点

/**
     * 删除节点
     * @throws Exception
     */
    @Test
    public void testDelete1() throws Exception {
        client.delete().forPath("/app1");
    }

/**
     * 删除包含子节点的节点
     * @throws Exception
     */
    @Test
    public void testDelete2() throws Exception {
        client.delete().deletingChildrenIfNeeded().forPath("/app5");
    }

 

/**
     * 必须成功删除
     * @throws Exception
     */
    @Test
    public void testDelete3() throws Exception {
        client.delete().guaranteed().forPath("/app5");
    }

修改节点

 /**
     * 修改节点数据
     * @throws Exception
     */
    @Test
    public void testSetData1() throws Exception {
        client.setData().forPath("/app2","呵呵".getBytes());
    }

/**
     * 修改节点数据，添加版本控制
     * 先获取当前节点数据的版本，修改时加上版本号，如果版本号不一致，则不能修改成功
     * @throws Exception
     */
    @Test
    public void testSetData2() 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","哈哈哈哈哈哈哈".getBytes());
    }

 

查询节点

/**
     * getData()，查询节点数据
     * @throws Exception
     */
    @Test
    public void testGet1() throws Exception {
        byte[] bytes = client.getData().forPath("/app2");
        String s = new String(bytes);
        System.out.println(s);
    }

/**
     * getChildren()，查询子节点
     * @throws Exception
     */
    @Test
    public void testLs() throws Exception {
        List<String> path = client.getChildren().forPath("/app5");
        System.out.println(path);
    }

/**
     * getData().storingStatIn(status).forPath("/app1")，查询节点状态信息
     * @throws Exception
     */
    @Test
    public void testStatus() throws Exception {
        Stat status = new Stat();
        client.getData().storingStatIn(status).forPath("/app1");
        System.out.println(status);
    }

 

 

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

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

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

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

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

ZooKeeper提供了三种Watcher：

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

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

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

/**
     * 对/app2节点添加监听器
     * @throws Exception
     */
    @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("app2发生变化了。。。。。。");
                byte[] data = nodeCache.getCurrentData().getData();
                System.out.println(new String(data));
            }
        });
        //3.开启监听
        nodeCache.start(true);
        while (true){

        }
    }

/**
     * 对/app1的子节点添加监听器
     * @throws Exception
     */
    @Test
    public void testPathChildrenCache() throws Exception {
        //1.创建pathChildrenCache对象
        PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/app1", true);
        //2.注册监听器对象
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                System.out.println("子节点发生改变了。。。。。。");
                System.out.println(pathChildrenCacheEvent);
                //如果是修改动作，获取到修改后的数据
                PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
                if(type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)){
                    byte[] data = pathChildrenCacheEvent.getData().getData();
                    System.out.println(new String(data));
                }
            }
        });
        //3.开启监听
        pathChildrenCache.start();
        while (true){

        }
    }

 

/**
     * 测试TreeCache
     * @throws Exception
     */
    @Test
    public void testTreeCache() throws Exception {
        //1.创建TreeCache对象
        TreeCache treeCache = new TreeCache(client, "/app1");
        //2.注册监听器对象
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                System.out.println("我被监听了。。。。。。");
                System.out.println(treeCacheEvent);
                TreeCacheEvent.Type type = treeCacheEvent.getType();
                if (type.equals(TreeCacheEvent.Type.NODE_UPDATED)){
                    System.out.println(new String(treeCacheEvent.getData().getData()));
                }
            }
        });
        //3.开启监听
        treeCache.start();
        while (true){

        }
    }

分布式锁实现

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

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

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

ZooKeeper分布式锁原理

核心思想：当客户端要获取锁，则创建节点，使用完锁，则删除该节点。

客户端获取锁时，在lock节点下创建临时顺序节点。

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

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

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

分布式锁案例 – 模拟12306售票

public class Ticket12306 implements Runnable{
    private int tickets = 10;
    private InterProcessMutex lock;
    public Ticket12306(){
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
        CuratorFramework client = CuratorFrameworkFactory.builder().connectString("121.199.32.186:2181").sessionTimeoutMs(5000).
                connectionTimeoutMs(5000).retryPolicy(retryPolicy).namespace("dyb").build();
        client.start();
        lock = new InterProcessMutex(client,"/lock");
    }
    @Override
    public void run() {
        while (true){
            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();
                }
            }

        }
    }
}

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

 Zookeeper 集群

Leader选举：

• Serverid ：服务器 ID

  比如有三台服务器，编号分别是1,2,3。

  编号越大在选择算法中的权重越大。

• Zxid ：数据 ID

  服务器中存放的最大数据ID.值越大说明数据  越新，在选举算法中数据越新权重越大。

• 在 Leader 选举 的过程中，如果 某台 ZooKeeper

    获得了超过半数的选票，

    则此ZooKeeper就可以成为Leader了。

Zookeeper 集群角色

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

• Leader 领导者 ：          

1. 处理事务请求

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

• Follower 跟随者 ：

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

2. 参与Leader选举投票

• Observer 观察者 ：

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