分布式服务框架 Zookeeper -- 管理分布式环境中的数据

Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理、Leader 选举、队列管理等。本文将从使用者角度详细介绍 Zookeeper 的安装和配置文件中各个配置项的意义，例举分析 Zookeeper 的典型的应用场景，用 Java 实现它们并给出示例代码。

一、安装和配置详解

本文介绍的 Zookeeper 是以 3.4.5 这个稳定版本为基础，最新的版本可以通过官网 http://zookeeper.apache.org/来获取，Zookeeper 的安装非常简单，下面将从单机模式、伪集群模式和全集群模式三个方面介绍 Zookeeper 在Linux下的安装和配置。

1、单机模式

单机安装非常简单，只要获取到 Zookeeper 的压缩包并解压到某个目录如：/home/fenglibin/soft/zookeeper-3.4.5 下，Zookeeper 的启动脚本在 bin 目录下，配置文件在安装目录的conf目录下。

1.1、配置文件介绍

在我们启动Zookeeper之前，首先我们需要编写Zookeeper的配置文件conf/zoo.cfg，Zookeeper启动的时候会从该文件中读取属性，如果不存在就会报错误，这个文件不用我们重头开始写，只需要将conf目录下面的zoo_sample.cfg拷贝一份并重命名为zoo.cfg，然后修改其中的属性即可。下面详细介绍一下，这个配置文件中各个配置项的意义。

# 这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。

tickTime=2000

# 这个配置项是用来配置 Zookeeper 接受客户端（这里所说的客户端不是用户连接 Zookeeper 服务器的客户端，而是 Zookeeper 服务器集群中连接到 Leader 的 Follower 服务器）初始化连接时最长能忍受多少个心跳时间间隔数。当已经超过 10 个心跳的时间（也就是 tickTime）长度后 Zookeeper 服务器还没有收到客户端的返回信息，那么表明这个客户端连接失败。总的时间长度就是 initLimit * tickTime = 10*2000=20 秒

initLimit=10

# 这个配置项标识 Leader 与 Follower 之间发送消息，请求和应答时间长度，最长不能超过多少个 tickTime 的时间长度，总的时间长度就是 syncLimit * tickTime = 5*2000=10 秒

syncLimit=5

# 是 Zookeeper 保存数据快照的目录，默认情况下，Zookeeper 将写数据的日志文件也保存在这个目录里。注：此目录不要是临时目录/tmp，因为大部份的Linux系统会在重启后清除该目录的内容，造成数据丢失。

dataDir=/home/fenglibin/soft/zookeeper-3.4.5/data

# 这个端口就是客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求。

clientPort=2181

# Be sure to read the maintenance section of the administrator guide before turning on autopurge.

# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance

# 这是个3.4.0中才引入的新特性，当启用该配置时，ZooKeeper将执行保留最新快照以及自动执行清除dataDir以及dataLogDir下面的旧的事务日志，只保留指定数量的最新事务日志数据，默认值为3，且最小值也必须为3。

#autopurge.snapRetainCount=3

# Purge task interval in hours

# 自动清除的时间间隔，以小时为单，如果设置为0，将不会执行该任务。默认值为0。

#autopurge.purgeInterval=1

所有的配置，可参看这里：http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html#sc_advancedConfiguration

1.2、Bin目录介绍及Zookeeper的启动

现在介绍bin，在该目录下有四个shell文件：

文件名	说明
zkCleanup.sh	用于清除旧的事务日志及快照
zkEnv.sh or zkEnv.bat	调用于运行时的环境变量，如classpath的设置，堆的大小设置等
zkServer.sh or zkServer.bat	用于执行Zookeeper的启动、停止及状态查看等操作
zkCli.sh or zkCli.bat	Zookeeper的shell客户端，如果是连接本机启动为默认端口2181的的Zookeeper，直接打入zkCli.sh命令，不需要任何参数

常用的肯定是zkServer.sh及zkCli.sh两个了，以下为使用介绍。

1.2.1、zkServer.sh的使用

#启动Zookeeper

./bin/zkServer.sh start

停止Zookeeper

./bin/zkServer.sh stop

#查看Zookeeper的状态

./bin/zkServer.sh status

zkServer.sh还有其它几个参数：start-foreground、restart、upgrade、print-cmd，分别用于在前台启动、重启、更新、操作。

1.2.2、zkCli.sh的使用

连接本机的Zookeeper

./bin/zkCli.sh

连接非本机的Zookeeper

./bin/zkCli.sh -server nginx2:2181

查看服务端的启动状态

表示服务端启动成功

1.2.3、命令行验证

请查看此文档中的示例：http://www.ibm.com/developerworks/library/bd-zookeeper/#N100BD

2、集群模式

Zookeeper 不仅可以单机提供服务，同时也支持多机组成集群来提供服务。实际上 Zookeeper 还支持另外一种伪集群的方式，也就是可以在一台物理机上运行多个 Zookeeper 实例，下面将介绍集群模式的安装和配置。

Zookeeper 的集群模式的安装和配置也不是很复杂，所要做的就是增加几个配置项。集群模式除了上面的单机的配置项外，还要增加下面几个配置项：

server.1=nginx1:2888:3888

server.2=nginx2:2888:3888

server.A=B：C：D：其中 A 是一个数字，表示这个是第几号服务器；B 是这个服务器的 ip 地址；C 表示的是这个服务器与集群中的 Leader 服务器交换信息的端口；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。

除了修改 zoo.cfg 配置文件，集群模式下还要配置一个文件 myid，这个文件在 dataDir 目录下，这个文件里面就有一个数据就是 A 的值，用来表示当前主机，如在server.1上面该值为1，在server.2上面，该值就是2。

二、控制集群中同时只有一台服务器“说话”的示例

场景一：有些时候需要控制集群中的服务器做缓存预热的时候，只需要其中一台服务器去做这个事情就可以了，因为缓存是类似Memcached的中央集群Cache，只需要有一台将数据成功加载了，那么集群中的其它服务器都可以访问，多台同时加台可能会造成数据冲突以及资源的浪费。

场景二：在共享存储的情况下，就是集群中的所有服务器都访问的相同的挂载存储，而此时应用需要执行JAR包动态加载，即有新的JAR包上传上来后各个应用服务器就立即加载，但是在笔者的场景下，JAR包的上传是单独的第三方应用去完成的，并且上传过去的JAR的名称不是以.jar结尾的，在各应用加载之前需要将其改名为.jar文件，如果不控制应用去改名，那么就会出现冲突，或者存在多个拷贝的情况下，虽然说不会存在问题，但是毕竟让人不舒服。

上面的两种场景，当然还可以其它的方式解决，如类似于Lucene的文件锁，或者使用Memcached锁，不一定非得使用ZooKeeper，不过在本例中是以ZooKeeper来解决问题的。

本例使用的是控制集群中的服务器同一时刻只会有一台“说话”，此时集群中的其它服务器是不能够“说话”的，以达到控制集群中的服务器同一时刻只会有一台在做此“说话”的任务，本例适合于集群中伪分布应用的布署的情况，以及全集群的布署的情况，并可在与ZooKeeper连接Session过期后，采用自动重连，下面是运行截图：

源码：

package org.apache.zookeeper.test.copy;

import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;

import org.apache.commons.io.FileUtils;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.KeeperException.NodeExistsException;
import org.apache.zookeeper.KeeperException.SessionExpiredException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 使用Zookeeper来控制集群中的服务器，同一时刻只会有一台做指定的事情，名称多台同时做会产生冲突的情况。<rb> 这个示例演示的是集群中的服务器，同一时刻只会有一台说话，当这台服务服务器说话时，其它的服务器不可以说话。<br>
 * 如果在操作的过程中，连接Zookeeper过期了，会自动进行重连；并确保其在同一个服务器上面布署多个示例也可以正常运行。<br>
 * 运行该示例：导入Zookeeper下面的Jar包，并且其依赖commons-io，其它就不需要了
 * 
 * @author fenglibin 2014-6-14 下午10:21:15
 */
public class SpeakOneByOneInCluster implements Watcher {

    // 连接Zookeeper Server的客户端连接
    static ZooKeeper            zk       = null;
    // 锁
    static Object               LOCK     = new Object();
    // 用户操作的根节点，与“/”是不同的，用户可以控制
    String                      root;
    // 当前节点的名称，由服务器的名称加随机数据组成，之所以使用这种方式，那是考虑到同一台服务器上可能会布署多个应用示例，而不一定是每个应用示例布署到集群的不同服务器上
    private static String       nodeName = "";
    // 节点锁，只有能够创建该节点的应用示例，才可以做指定的事情，如本例中的说话
    private static String       LOCK_NODE;
    // 用于表示当前应用是否拿到了节点锁，然后根据是否拿到节点锁，才可以做指定的事情，如本例中的说话
    static boolean              getLock;
    String                      address;
    // 日志文件
    File                        logFile  = new File("D:/test/logFile.txt");
    private static final Logger LOG;
    static {
        // Keep these two lines together to keep the initialization order explicit
        LOG = LoggerFactory.getLogger(SpeakOneByOneInCluster.class);
    }

    SpeakOneByOneInCluster(String address){
        this.address = address;
        if (zk == null) {
            try {
                connect(address);
            } catch (IOException e) {
                writeLog(e.toString());
                zk = null;
            }
        }
    }

    void connect(String address) throws IOException {
        writeLog("Starting ZK:");
        zk = new ZooKeeper(address, 2181, this);
        writeLog("Finished starting ZK: " + zk);
    }

    synchronized public void process(WatchedEvent event) {
        synchronized (LOCK) {
            if (!event.getPath().equals(LOCK_NODE)) {
                LOCK.notify();
            }
        }
    }

    /**
     * 用于选举可用于做事情的应用
     */
    static public class Barrier extends SpeakOneByOneInCluster implements Runnable {

        private static final Logger LOG;
        static {
            // Keep these two lines together to keep the initialization order explicit
            LOG = LoggerFactory.getLogger(Barrier.class);
        }
        String                      nodeName;

        /**
         * Barrier constructor
         * 
         * @param address
         * @param root
         * @param size
         */
        Barrier(String address, String root){
            super(address);
            this.root = root;
            // Create barrier node
            if (zk != null) {
                try {
                    Stat s = zk.exists(root, false);
                    if (s == null) {
                        zk.create(root, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                    }
                } catch (KeeperException e) {
                    writeLog("Keeper exception when instantiating queue: " + e.toString());
                } catch (InterruptedException e) {
                    writeLog("Interrupted exception");
                }
            }
            // My node name
            try {
                this.nodeName = new StringBuilder(InetAddress.getLocalHost().getCanonicalHostName()).append((int) (Math.random() * 100)).toString();
            } catch (UnknownHostException e) {
                writeLog(e.toString());
            }
        }

        /**
         * Join barrier
         * 
         * @return
         * @throws KeeperException
         * @throws InterruptedException
         */

        void lock() throws KeeperException, InterruptedException {
            Stat stat = zk.exists(LOCK_NODE, false);
            if (stat != null) {
                return;
            }
            zk.create(LOCK_NODE, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            writeLog(SpeakOneByOneInCluster.nodeName + ":create node " + LOCK_NODE);
            getLock = Boolean.TRUE;
            List<String> childs = zk.getChildren(root, true);
            // 节点存在了就返回不处理
            if (!(childs == null || childs.size() == 0)) {
                return;
            }
            zk.create(root + "/" + nodeName, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            writeLog(SpeakOneByOneInCluster.nodeName + ":create node " + root + "/" + nodeName);
            SpeakOneByOneInCluster.nodeName = this.nodeName;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    lock();
                } catch (NodeExistsException e) {
                } catch (SessionExpiredException e) {
                    try {
                        // Session过期了，进行重连
                        connect(address);
                    } catch (IOException e1) {
                        LOG.error(e1.getMessage(), e1);
                    }
                } catch (Exception e) {
                    LOG.error(e.getMessage(), e);
                }
            }
        }
    }

    /**
     * Producer-Consumer queue
     */
    static public class Speak extends SpeakOneByOneInCluster implements Runnable {

        private static final Logger LOG;
        static {
            // Keep these two lines together to keep the initialization order explicit
            LOG = LoggerFactory.getLogger(Speak.class);
        }

        /**
         * Constructor of speaker
         * 
         * @param address
         * @param root
         */
        Speak(String address, String root){
            super(address);
            this.root = root;
            // Create ZK node name
            if (zk != null) {
                try {
                    Stat s = zk.exists(this.root, false);
                    if (s == null) {
                        zk.create(this.root, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                    }
                } catch (SessionExpiredException e) {
                    try {
                        // Session过期了，进行重连
                        connect(address);
                    } catch (IOException e1) {
                        LOG.error(e1.getMessage(), e1);
                    }
                } catch (KeeperException e) {
                    writeLog("Keeper exception when instantiating queue: " + e.toString());
                } catch (InterruptedException e) {
                    writeLog("Interrupted exception");
                }
            }
        }

        /**
         * Add element to the queue.
         * 
         * @param i
         * @return
         */

        boolean check() {
            try {
                if (getLock == Boolean.FALSE) {
                    return false;
                }
                List<String> childs = zk.getChildren(root, true);
                if (childs == null || childs.size() == 0) {
                    return false;
                }
                if (childs.size() != 1) {
                    throw new RuntimeException("childs's size is " + childs.size() + ", it must be 1.");
                }
                if (childs.get(0).endsWith(SpeakOneByOneInCluster.nodeName)) {
                    return true;
                }
                return false;
            } catch (SessionExpiredException e) {
                try {
                    // Session过期了，进行重连
                    connect(address);
                } catch (IOException e1) {
                    LOG.error(e1.getMessage(), e1);
                }
                return false;
            } catch (Exception e) {
                LOG.error(e.getMessage(), e);
                return false;
            }

        }

        void speak() throws InterruptedException {
            while (true) {
                // writeLog(CopyOneFileInMultiVM.choosedNodeName + ":try speak...");
                synchronized (LOCK) {
                    if (!check()) {
                        // writeLog(CopyOneFileInMultiVM.choosedNodeName + ":copy condition not ready,wait.");
                        LOCK.wait();
                    } else {
                        writeLog(SpeakOneByOneInCluster.nodeName + ":speak now");
                        doSpeak();
                    }
                }
            }
        }

        void doSpeak() {
            try {
                writeLog(SpeakOneByOneInCluster.nodeName + ": Now only I can speak. Let me sleep 5s.");
                Thread.sleep(5000);
                writeLog(SpeakOneByOneInCluster.nodeName + ": I week up now.");
                unlock();
            } catch (SessionExpiredException e) {
                try {
                    connect(address);
                    unlock();
                } catch (Exception e1) {
                    LOG.error(e1.getMessage(), e1);
                }
            } catch (Exception e) {
                LOG.error(e.getMessage(), e);
            }
        }

        /**
         * delete the lock node
         * 
         * @return
         * @throws KeeperException
         * @throws InterruptedException
         */

        void unlock() throws KeeperException, InterruptedException {
            writeLog(SpeakOneByOneInCluster.nodeName + ":Begin to delete node " + SpeakOneByOneInCluster.nodeName + " and node " + LOCK_NODE);
            zk.delete(root + "/" + SpeakOneByOneInCluster.nodeName, 0);
            zk.delete(LOCK_NODE, 0);
            getLock = Boolean.FALSE;
            writeLog(SpeakOneByOneInCluster.nodeName + ":Resource release OK. It's you turn, bye.");
        }

        @Override
        public void run() {
            try {
                speak();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                LOG.error(e.getMessage(), e);
            }
        }
    }

    public void writeLog(String str) {
        try {
            System.out.println(str);
            FileUtils.writeStringToFile(logFile, str + "\n", true);
        } catch (IOException e) {
            LOG.error(e.getMessage(), e);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LOCK_NODE = "/zk_test/lock";
        new Thread(new Barrier("localhost", "/zk_test/chooseCopyMachine")).start();
        new Thread(new Speak("localhost", "/zk_test/chooseCopyMachine")).start();
        Runtime.getRuntime().addShutdownHook(new Thread() {

            public void run() {
                try {
                    if (zk.exists(LOCK_NODE, false) != null) {
                        zk.delete(LOCK_NODE, -1);
                    }
                    zk.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    LOG.error(e.getMessage(), e);
                }
            }
        });
    }
}