ZooKeeper的三种典型应用场景

引言

　　zookeeper是中典型的pub/sub模式的分布式数据管理与协调框架，开发人员可以使用它进行分布式数据的发布与订阅。另外，其丰富的数据节点类型可以交叉使用，配合watcher事件通知机制，可以应用于分布式都会涉及的一些核心功能：数据发布/订阅、master选举、命名服务、分布式协调/通知、集群管理、分布式锁、分布式队列等。本博文主要介绍：发布/订阅、分布式锁、master选举三种最常用的场景

　　本文中的代码示例均是由curator客户端编写的，已经对zookeeper原生api做好很多封装。参考资料《从paxos到zookeeper  分布式一致性原理与实践》（有需要电子pdf的朋友，可以评论私信我）

 

---

 

一、数据发布/订阅

1、基本概念

（1）数据发布/订阅系统即所谓的配置中心，也就是发布者将数据发布到zookeeper的一个节点或者一系列节点上，提供订阅者进行数据订阅，从而实现动态更新数据的目的，实现配置信息的集中式管理和数据的动态更新。zookeeper采用的是推拉相结合的方式：客户端向服务器注册自己需要关注的节点，一旦该节点的数据发生改变，那么服务端就会向相应的客户端发送wacher事件通知，客户端接收到消息通知后，需要主动到服务端获取最新的数据。

（2）实际系统开发过程中：我们可以将初始化配置信息放到节点上集中管理，应用在启动时都会主动到zookeeper服务端进行一次配置读取，同时在指定节点注册watcher监听，主要配置信息一旦变更，订阅者就可以获取读取最新的配置信息。通常系统中需要使用一些通用的配置信息，比如机器列表信息、运行时的开关配置、数据库配置信息等全局配置信息，这些都会有以下3点特性：

　　1） 数据量通常比较小（通常是一些配置文件）

　　2） 数据内容在运行时会经常发生动态变化（比如数据库的临时切换等）

　　3） 集群中各机器共享，配置一致（比如数据库配置共享）。

（3）利用的zookeeper特性是：zookeeper对任何节点（包括子节点）的变更，只要注册wacther事件（使用curator等客户端工具已经被封装好）都可以被其它客户端监听

2、代码示例

package com.lijian.zookeeper.demo;

import org.apache.curator.retrypolicy;
import org.apache.curator.framework.curatorframework;
import org.apache.curator.framework.curatorframeworkfactory;
import org.apache.curator.framework.recipes.cache.nodecache;
import org.apache.curator.framework.recipes.cache.nodecachelistener;
import org.apache.curator.retry.exponentialbackoffretry;
import org.apache.zookeeper.createmode;

import java.util.concurrent.countdownlatch;

public class zookeeper_subsciption {
    private static final string address = "xxx.xxx.xxx.xxx:2181";
    private static final int session_timeout = 5000;
    private static final string path = "/configs";
    private static retrypolicy retrypolicy = new exponentialbackoffretry(1000, 3);
    private static string config = "jdbc_configuration";
    private static countdownlatch countdownlatch = new countdownlatch(4);

    public static void main(string[] args) throws exception {
        // 订阅该配置信息的集群节点（客户端）:sub1-sub3
        for (int i = 0; i < 3; i++) {
            curatorframework consumerclient = getclient();
            subscribe(consumerclient, "sub" + string.valueof(i));
        }
        // 更改配置信息的集群节点（客户端）:pub
        curatorframework publisherclient = getclient();
        publish(publisherclient, "pub");

    }
    private static void init() throws exception {
        curatorframework client = curatorframeworkfactory.builder()
                .connectstring(address)
                .sessiontimeoutms(session_timeout)
                .retrypolicy(retrypolicy)
                .build();
        client.start();
        // 检查节点是否存在，不存在则初始化创建
        if (client.checkexists().forpath(path) == null) {
            client.create()
                    .creatingparentsifneeded()
                    .withmode(createmode.ephemeral)
                    .forpath(path, config.getbytes());
        }
    }


    /**
     * 创建客户端并且初始化建立一个存储配置数据的节点
     *
     * @return
     * @throws exception
     */
    private static curatorframework getclient() throws exception {
        curatorframework client = curatorframeworkfactory.builder()
                .connectstring(address)
                .sessiontimeoutms(session_timeout)
                .retrypolicy(retrypolicy)
                .build();
        client.start();
        if (client.checkexists().forpath(path) == null) {
            client.create()
                    .creatingparentsifneeded()
                    .withmode(createmode.ephemeral)
                    .forpath(path, config.getbytes());
        }
        return client;
    }

    /**
     * 集群中的某个节点机器更改了配置信息：即发布了更新了数据
     *
     * @param client
     * @throws exception
     */
    private static void publish(curatorframework client, string znode) throws exception {

        system.out.println("节点[" + znode + "]更改了配置数据...");
        client.setdata().forpath(path, "configuration".getbytes());
        countdownlatch.await();
    }

    /**
     * 集群中订阅的节点客户端（机器）获得最新的配置数据
     *
     * @param client
     * @param znode
     * @throws exception
     */
    private static void subscribe(curatorframework client, string znode) throws exception {
        // nodecache监听zookeeper数据节点本身的变化
        final nodecache cache = new nodecache(client, path);
        // 设置为true：nodecache在第一次启动的时候就立刻从zookeeper上读取节点数据并保存到cache中
        cache.start(true);
        system.out.println("节点["+ znode +"]已订阅当前配置数据：" + new string(cache.getcurrentdata().getdata()));
        // 节点监听
        countdownlatch.countdown();
        cache.getlistenable().addlistener(new nodecachelistener() {
            @override
            public void nodechanged() {
                system.out.println("配置数据已发生改变, 节点[" + znode + "]读取当前新配置数据: " + new string(cache.getcurrentdata().getdata()));
            }
        });
    }
}

运行结果：节点[pub]更改了配置数据为“configuration”，订阅"/configs"节点的sub1-sub3观测到配置被改变，立马读取当前最新的配置数据“configuration”

 

二、master选举

1、基本概念

　　（1）在一些读写分离的应用场景中，客户端写请求往往是由master处理的，而另一些场景中，master则常常负责处理一些复杂的逻辑，并将处理结果同步给集群中其它系统单元。比如一个广告投放系统后台与zookeeper交互，广告id通常都是经过一系列海量数据处理中计算得到（非常消耗i/o和cpu资源的过程），那就可以只让集群中一台机器处理数据得到计算结果，之后就可以共享给整个集群中的其它所有客户端机器。

　　（2）利用zookeeper的特性：利用zookeeper的强一致性，即能够很好地保证分布式高并发情况下节点的创建一定能够保证全局唯一性，zookeeper将会保证客户端无法重复创建一个已经存在的数据节点，也就是说如果多个客户端请求创建同一个节点，那么最终一定只有一个客户端请求能够创建成功，这个客户端就是master，而其它客户端注在该节点上注册子节点wacther，用于监控当前master是否存活，如果当前master挂了，那么其余客户端立马重新进行master选举。

　　（3）竞争成为master角色之后，创建的子节点都是临时顺序节点，比如：_c_862cf0ce-6712-4aef-a91d-fc4c1044d104-lock-0000000001，并且序号是递增的。需要注意的是这里有"lock"单词，这说明zookeeper这一特性，也可以运用于分布式锁。

　　　

 

2、代码示例

 

package com.lijian.zookeeper.demo;

import org.apache.curator.retrypolicy;
import org.apache.curator.framework.curatorframework;
import org.apache.curator.framework.curatorframeworkfactory;
import org.apache.curator.framework.recipes.leader.leaderselector;
import org.apache.curator.framework.recipes.leader.leaderselectorlisteneradapter;
import org.apache.curator.retry.exponentialbackoffretry;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.atomic.atomicinteger;

public class zookeeper_master {

    private static final string address="xxx.xxx.xxx.xxx:2181";
    private static final int session_timeout=5000;
    private static final string master_path = "/master_path";
    private static final int client_count = 5;

    private static retrypolicy retrypolicy = new exponentialbackoffretry(1000, 3);


    public static void main(string[] args) throws interruptedexception {

        executorservice service = executors.newfixedthreadpool(client_count);
        for (int i = 0; i < client_count; i++) {
            final string index = string.valueof(i);
            service.submit(() -> {
                masterselect(index);
            });
        }
    }

    private static void  masterselect(final string znode){
        // client成为master的次数统计
        atomicinteger leadercount = new atomicinteger(1);
        curatorframework client = curatorframeworkfactory.builder()
                .connectstring(address)
                .sessiontimeoutms(session_timeout)
                .retrypolicy(retrypolicy)
                .build();
        client.start();
        // 一旦执行完takeleadership，就会重新进行选举
        leaderselector selector = new leaderselector(client, master_path, new leaderselectorlisteneradapter() {
            @override
            public void takeleadership(curatorframework curatorframework) throws exception {
                system.out.println("节点["+ znode +"]成为master");
                system.out.println("节点["+ znode +"]已经成为master次数："+ leadercount.getandincrement());
                // 睡眠5s模拟成为master后完成任务
                thread.sleep(5000);
                system.out.println("节点["+ znode +"]释放master");
            }
        });
        // autorequeue自动重新排队：使得上一次选举为master的节点还有可能再次成为master
        selector.autorequeue();
        selector.start();
    }
}

运行结果：由于执行selector.autorequeue()方法，被选举为master后的节点可能会再次获被选举为master，所以会一直循环执行，以下只截图部分。其中获取成为master的次数充分表明了master选举的公平性。

　

 

 

三、分布式锁

1、基本概念

　　（1）对于排他锁：zookeeper通过数据节点表示一个锁，例如/exclusive_lock/lock节点就可以定义一个锁，所有客户端都会调用create()接口，试图在/exclusive_lock下创建lock子节点，但是zookeeper的强一致性会保证所有客户端最终只有一个客户创建成功。也就可以认为获得了锁，其它线程watcher监听子节点变化（等待释放锁，竞争获取资源）。

　　　　 对于共享锁：zookeeper同样可以通过数据节点表示一个锁，类似于/shared_lock/[hostname]-请求类型（读/写）-序号的临时节点，比如/shared_lock/192.168.0.1-r-0000000000

2、代码示例

curator提供的有四种锁，分别如下：

　　（1）interprocessmutex：分布式可重入排它锁

　　（2）interprocesssemaphoremutex：分布式排它锁

　　（3）interprocessreadwritelock：分布式读写锁

　　（4）interprocessmultilock：将多个锁作为单个实体管理的容器

主要是以interprocessmutex为例，编写示例：

package com.lijian.zookeeper.demo;

import org.apache.curator.retrypolicy;
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.countdownlatch;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;

public class zookeeper_lock {
    private static final string address = "xxx.xxx.xxx.xxx:2181";
    private static final int session_timeout = 5000;
    private static final string lock_path = "/lock_path";
    private static final int client_count = 10;

    private static retrypolicy retrypolicy = new exponentialbackoffretry(1000, 3);
    private static int resource = 0;

    public static void main(string[] args){
        executorservice service = executors.newfixedthreadpool(client_count);
        for (int i = 0; i < client_count; i++) {
            final string index = string.valueof(i);
            service.submit(() -> {
                distributedlock(index);
            });
        }
    }

    private static void distributedlock(final string znode) {
        curatorframework client = curatorframeworkfactory.builder()
                .connectstring(address)
                .sessiontimeoutms(session_timeout)
                .retrypolicy(retrypolicy)
                .build();
        client.start();
        final interprocessmutex lock = new interprocessmutex(client, lock_path);
        try {
//            lock.acquire();
            system.out.println("客户端节点[" + znode + "]获取lock");
            system.out.println("客户端节点[" + znode + "]读取的资源为：" + string.valueof(resource));
            resource ++;
//            lock.release();
            system.out.println("客户端节点[" + znode + "]释放lock");

        } catch (exception e) {
            e.printstacktrace();
        }
    }
}

 

运行结果：加锁后可以从左图看到读取的都是最新的资源值。如果去掉锁的话读取的资源值不能保证是最新值看右图