ZooKeeper 典型应用场景-Master选举

master选举

1、使用场景及结构

　　现在很多时候我们的服务需要7*24小时工作，假如一台机器挂了，我们希望能有其它机器顶替它继续工作。此类问题现在多采用master-salve模式，也就是常说的主从模式，正常情况下主机提供服务，备机负责监听主机状态，当主机异常时，可以自动切换到备机继续提供服务(这里有点儿类似于数据库主库跟备库，备机正常情况下只监听，不工作)，这个切换过程中选出下一个主机的过程就是master选举。

　　对于以上提到的场景，传统的解决方式是采用一个备用节点，这个备用节点定期给当前主节点发送ping包，主节点收到ping包后会向备用节点发送应答ack，当备用节点收到应答，就认为主节点还活着，让它继续提供服务，否则就认为主节点挂掉了，自己将开始行使主节点职责。如图1所示：

　　　　图1

　　　但这种方式会存在一个隐患，就是网络故障问题。看一下图2：

　　　　　　　　　　图2

　　　也就是说，我们的主节点并没有挂掉，只是在备用节点ping主节点，请求应答的时候发生网络故障，这样我们的备用节点同样收不到应答，就会认为主节点挂掉，然后备机会启动自己的master实例。这样就会导致系统中有两个主节点，也就是双master。出现双master以后，我们的从节点会将它做的事情一部分汇报给主节点，一部分汇报给备用节点，这样服务就乱套了。为了防止这种情况出现，我们可以考虑采用zookeeper，虽然它不能阻止网络故障的出现，但它能保证同一时刻系统中只存在一个主节点。我们来看zookeeper是怎么实现的：

　　在此处，抢主程序是包含在服务程序中，需要程序员来手动写抢主逻辑的。

　　一点额外的话：zookeeper自己在集群环境下的抢主算法有三种，可以通过配置文件来设定，默认采用FastLeaderElection，不作赘述；此处主要讨论集群环境中，应用程序利用master的特点，自己选主的过程。程序自己选主，每个人都有自己的一套算法，有采用“最小编号”的，有采用类似“多数投票”的，各有优劣，本文的算法仅作演示理解使用：

　　结构图：

　　结构图解释：左侧树状结构为zookeeper集群，右侧为程序服务器。所有的服务器在启动的时候，都会订阅zookeeper中master节点的删除事件，以便在主服务器挂掉的时候进行抢主操作；所有服务器同时会在servers节点下注册一个临时节点（保存自己的基本信息），以便于应用程序读取当前可用的服务器列表。

　　选主原理介绍：zookeeper的节点有两种类型，持久节点跟临时节点。临时节点有个特性，就是如果注册这个节点的机器失去连接(通常是宕机)，那么这个节点会被zookeeper删除。选主过程就是利用这个特性，在服务器启动的时候，去zookeeper特定的一个目录下注册一个临时节点(这个节点作为master，谁注册了这个节点谁就是master)，注册的时候，如果发现该节点已经存在，则说明已经有别的服务器注册了(也就是有别的服务器已经抢主成功)，那么当前服务器只能放弃抢主，作为从机存在。同时，抢主失败的当前服务器需要订阅该临时节点的删除事件，以便该节点删除时(也就是注册该节点的服务器宕机了或者网络断了之类的)进行再次抢主操作。从机具体需要去哪里注册服务器列表的临时节点，节点保存什么信息，根据具体的业务不同自行约定。选主的过程，其实就是简单的争抢在zookeeper注册临时节点的操作，谁注册了约定的临时节点，谁就是master。

　　ps：本文的例子中，并未用到结构图server节点下的数据。但换一种算法或者业务场景就会用到，算法比如提到的最小编号，主要逻辑是主节点挂掉后，从节点里边编号最小的成为主节点，此时会用到该节点内容。换一种业务场景：集群环境中，有很多任务要处理，主节点负责接收任务，并根据一定算法将任务分配到不同的机器上执行；这种情况下，主节点跟从节点的职责也是不同的，主节点挂掉也会涉及到从节点进行master选举的问题。这种情况下，很显然，作为主节点需要知道当前有多少个从节点还活着，那么此时也会需要用到servers节点下的数据了。

架构图：

1)、左边区域代表zk集群

2)、右边代表3台工作服务器

　　它们在各自启动过程中首先会去zk集群的Servers节点下创建临时节点，并把自己的基本信息写入到临时节点，这个过程叫做服务注册。系统中的其他服务可以通过获取Servers节点的子节点列表来了解当前系统哪些服务器可用。这个过程叫做服务发现。

　　接着这些服务器会去尝试创建Master节点，谁能创建成功，谁就作为master向外提供服务。其他机器作为slave，所有的slave必须关注master节点的删除事件。

一个临时节点在创建它的会话失效以后会自动的被zk删除掉，而创建会话的机器宕机会直接导致会话的失效。我们可以监听master节点的失效来了解master节点是否宕机，一旦宕机，就必须发起新一轮的master选举。新选举出的master继续提供服务。

程序主体流程：

work server在启动的时候首先会注册监听master节点的删除事件，紧接着会尝试创建master节点，如果可以创建成功，说明自己就是master，如果不能说明当前系统中master节点已存在，其他机器争抢到了master权利，这个时候我们可以读取master节点的数据内容，如果可以读取成功，就把master的基本信息放入自己的内存变量中。如果不能，说明在读取master的瞬间master宕机了。这个时候需要发起新一轮的master 选举来争抢master权利。

应对网络抖动流程：

系统的核心类：

Work Server：对应架构图的Work Server，是主工作类。

Running Data：用于描述Work Server的基本信息。

LeaderSelectorZkClient：作为调度器来启动停止Work Server。

2、编码实现

　　主要有两个类，WorkServer为主服务类，RunningData用于记录运行数据。因为是简单的demo，我们只做抢master节点的编码，对于从节点应该去哪里注册服务列表信息，不作编码。

　　采用zkClient实现，代码如下：

　　WorkServer类：

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

import org.I0Itec.zkclient.IZkDataListener;

import org.I0Itec.zkclient.ZkClient;

import org.I0Itec.zkclient.exception.ZkException;

import org.I0Itec.zkclient.exception.ZkInterruptedException;

import org.I0Itec.zkclient.exception.ZkNoNodeException;

import org.I0Itec.zkclient.exception.ZkNodeExistsException;

import org.apache.zookeeper.CreateMode;

public class WorkServer {

    private volatile boolean running = false; //记录服务器运行状态

    private ZkClient zkClient; //开源客户端-zk客户端

    private static final String MASTER_PATH = "/master"; //master节点对应在zookeeper中的节点路径

    private IZkDataListener dataListener; //监听zookeeper中master节点的删除事件

    private RunningData serverData; //集群中当前服务器节点的基本信息

    private RunningData masterData; //集群中master节点的基本信息

    private ScheduledExecutorService delayExector = Executors.newScheduledThreadPool(1);

    private int delayTime = 5;

    public WorkServer(RunningData rd) {

        this.serverData = rd;

        this.dataListener = new IZkDataListener() {

            public void handleDataDeleted(String dataPath) throws Exception {//节点删除事件

                //takeMaster();

                if (masterData != null && masterData.getName().equals(serverData.getName())) {

                    takeMaster();

                } else {

                    delayExector.schedule(new Runnable() {

                        public void run() {

                            takeMaster();

                        }

                    }, delayTime, TimeUnit.SECONDS);

                }

            }

            public void handleDataChange(String dataPath, Object data)

                    throws Exception {//节点内容变化事件

            }

        };

    }

    public ZkClient getZkClient() {

        return zkClient;

    }

    public void setZkClient(ZkClient zkClient) {

        this.zkClient = zkClient;

    }

    /**

     * 服务start方法

     *

     * @throws Exception

     */

    public void start() throws Exception {

        if (running) {

            throw new Exception("server has startup...");

        }

        running = true;

        zkClient.subscribeDataChanges(MASTER_PATH, dataListener);

        takeMaster();

    }

    /**

     * 服务stop方法

     *

     * @throws Exception

     */

    public void stop() throws Exception {

        if (!running) {

            throw new Exception("server has stoped");

        }

        running = false;

        delayExector.shutdown();

        zkClient.unsubscribeDataChanges(MASTER_PATH, dataListener);

        releaseMaster();

    }

    /**

     * 争抢master权利

     */

    private void takeMaster() {

        if (!running) {

            return;

        }

        try {

            zkClient.create(MASTER_PATH, serverData, CreateMode.EPHEMERAL);

            masterData = serverData;

            System.out.println(serverData.getName() + " is master");

            // 以下代码作为演示,每隔5秒钟释放master权利

            delayExector.schedule(new Runnable() {

                public void run() {

                    if (checkMaster()) {

                        releaseMaster();

                    }

                }

            }, 5, TimeUnit.SECONDS);

        } catch (ZkNodeExistsException e) {

            RunningData runningData = zkClient.readData(MASTER_PATH, true);

            if (runningData == null) {

                takeMaster();

            } else {

                masterData = runningData;

            }

        } catch (Exception e) {

            // ignore;

        }

    }

    /**

     * 释放master权利

     */

    private void releaseMaster() {

        if (checkMaster()) {

            zkClient.delete(MASTER_PATH);

        }

    }

    /**

     * 检测是否是master

     */

    private boolean checkMaster() {

        try {

            RunningData eventData = zkClient.readData(MASTER_PATH);

            masterData = eventData;

            if (masterData.getName().equals(serverData.getName())) {

                return true;

            }

            return false;

        } catch (ZkNoNodeException e) {

            return false;

        } catch (ZkInterruptedException e) {

            return checkMaster();

        } catch (ZkException e) {

            return false;

        }

    }

}

　　RunningData类：

import java.io.Serializable;

public class RunningData implements Serializable {

    private static final long serialVersionUID = 4260577459043203630L;

    private Long cid;

    private String name;

    public Long getCid() {

        return cid;

    }

    public void setCid(Long cid) {

        this.cid = cid;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

　　说明：在实际生产环境中，可能会由于插拔网线等导致网络短时的不稳定，也就是网络抖动。由于正式生产环境中可能server在zk上注册的信息是比较多的，而且server的数量也是比较多的，那么每一次切换主机，每台server要同步的数据量(比如要获取谁是master，当前有哪些salve等信息，具体视业务不同而定)也是比较大的。那么我们希望，这种短时间的网络抖动最好不要影响我们的系统稳定，也就是最好选出来的master还是原来的机器，那么就可以避免发现master更换后，各个salve因为要同步数据等导致的zk数据网络风暴。所以在WorkServer中，54-63行，我们抢主的时候，如果之前主机是本机，则立即抢主，否则延迟5s抢主。这样就给原来主机预留出一定时间让其在新一轮选主中占据优势，从而利于环境稳定。

　　测试代码：

import com.sql.zookeeper.common.ZookeeperConstant;

import org.I0Itec.zkclient.ZkClient;

import org.I0Itec.zkclient.serialize.SerializableSerializer;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

public class LeaderSelectorZkClient {

    //启动的服务个数

    private static final int CLIENT_QTY = 10;

    public static void main(String[] args) throws Exception {

        //保存所有zkClient的列表

        List<ZkClient> clients = new ArrayList<ZkClient>();

        //保存所有服务的列表

        List<WorkServer> workServers = new ArrayList<WorkServer>();

        try {

            for (int i = 0; i < CLIENT_QTY; ++i) {

                //创建zkClient

                ZkClient client = new ZkClient(ZookeeperConstant.ZK_CONNECTION_STRING, 5000, 5000, new SerializableSerializer());

                clients.add(client);

                //创建serverData

                RunningData runningData = new RunningData();

                runningData.setCid(Long.valueOf(i));

                runningData.setName("Client #" + i);

                //创建服务

                WorkServer workServer = new WorkServer(runningData);

                workServer.setZkClient(client);

                workServers.add(workServer);

                workServer.start();

            }

            System.out.println("敲回车键退出！\n");

            new BufferedReader(new InputStreamReader(System.in)).readLine();

        } finally {

            System.out.println("Shutting down...");

            for (WorkServer workServer : workServers) {

                try {

                    workServer.stop();

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

            for (ZkClient client : clients) {

                try {

                    client.close();

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

　　两次测试，本地模拟10台server，分别不启用防止网络抖动跟启动防抖动两次测试结果如下：

　　未启动防抖动：

　　启用防抖动：

　　可以看到，未启用的时候，断线后重新选出的主机是随机的，没规律；启用防抖动后，每次选出的master都是id为0的机器。

-----------------------------------------------------------------------------------------------------------------------------

　　至此，我们已经通过编码实现了简单的master选举。但是，不知你有没有发现，，，，这个选主过程的代码还真是麻烦啊！

　　我们只是做一个demo，其中并未考虑复杂的业务场景，但其中的监听，异常等代码的处理还是让我觉得有些头大，怎么办？Curator应运而生！

　　为了熟悉Apache Curator，接下来，将用curator来实现master选举的demo。

巴特西

ZooKeeper 典型应用场景-Master选举

最新文章

热门文章