zookeeper集群选主原理

前言： ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是大数据领域的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。而在大数据中最主要的作用就是集群选主！
本文中讲解均以3台节点zookeeper为例！

一、zookeeper自身选举

zookeeper自身选举分为两类，一是全新集群选举，二是非全新集群选主~

1、全新集群选主

1）先启动hadoop01（id=1），hadoop01找集群中的leader，发现没有leader，发现选主，将票投给自己，hadoop01获取一票，没有过半选举，节点是looking状态；
2）启动hadoop02（id=2），hadoop02启动完成，找集群中的leader，发现没有，发起选主，开始投票，id小的强制将票投给id大的，hadoop01将票投给id=2（hadoop02），hadoop02将票投给自己，id=2（hadoop02）获取到两票，过半选举，hadoop02-leader，hadoop01将自己状态切换为following；
3）hadoop03（id=3）启动的时候，发现集群中已经有leader，将自己的状态切换为following

2、非全新集群选主

依据： zxid、myid和逻辑时钟（标识每次投票的轮数，要想进行投票选举所有节点逻辑时钟要一致）
过程：
1）各个节点的逻辑时钟统一，如果某一个节点的逻辑时钟小，这次投票忽略，重新投票直到逻辑时钟一致；
2）逻辑时钟一致后，按照数据更新级别zxid（zxid越大，数据越新），zxid大的胜出；
3）在zxid相同、最新的节点中选取id最大的

二、zookeeper给其他软件提供选举

强调： 这里的选举指的是zookeeper为外部服务提供的leader选举策略，不是zookeeper自身的leader的选举。而zookeeper为外部提供的选举服务也分为两大类，原生的和curator框架的。

1、基于原生zookeeper的选举策略

1.1公平模式

先到先得，后者监视前者
1）创建Leader父节点，如/chroot，并将其设置为persist节点；
2）各客户端通过在/chroot下创建Leader节点，如/chroot/leader，来竞争Leader。该节点应被设置为ephemeral_sequential；
3）客户端通过getChildren方法获取/chroot/下所有子节点，如果其注册的节点的id在所有子节点中最小，则当前客户端竞选Leader成功；
4）否则，在前面一个节点上注册watch，一旦前者被删除，则它得到通知，返回step 3（并不能直接认为自己成为新Leader，因为可能前面的节点只是宕机了）；
5）Leader节点可通过自行删除自己创建的节点以放弃Leader。

1.2非公平模式

抢注Leader节点—非公平
1）创建Leader父节点，如/chroot，并将其设置为persist节点；
2）各客户端通过在/chroot下创建Leader节点，如/chroot/leader，来竞争Leader。该节点应被设置为ephemeral；
3）若某创建Leader节点成功，则该客户端成功竞选为Leader；
4）若创建Leader节点失败，则竞选Leader失败，在/chroot/leader节点上注册exist的watch，一旦该节点被删除则获得通知；
5）Leader可通过删除Leader节点来放弃Leader；
6）如果Leader宕机，由于Leader节点被设置为ephemeral，Leader节点会自行删除。而其它节点由于在Leader节点上注册了watch，故可得到通知，参与下一轮竞选，从而保证总有客户端以Leader角色工作。

2、基于curator的选举策略

2.0curator框架入门

因为zookeeper的原生的api操作的复杂度过高，所以一般在开发中都不怎么用，而是选择使用一个对zookeeper client封装了的框架——apache curator，该框架是由netflix公司开源贡献给apache。

2.0.1引入依赖

<!-- curator client -->
<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-framework</artifactId>
  <version>2.8.0</version>
  <!-- 移除curator中关联的zookeeper依赖-->
  <exclusions>
    <exclusion>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
    </exclusion>
  </exclusions>
</dependency>

2.0.2API操作

/**
  * curator的api操作
  *
  * CuratorFramework
  *
  * 该实例的创建CuratorFrameworkFactory --->工厂模式
  * 指定这个namespace的作用相当于
  *     user database,
  * 后续的所有操作都是在这个namespace下面的操作
  * 如果不加namespace，所有的操作就在/根目录下面进行操作
  *
  * 在curator中指定相关的目录，需要调用不同的builder的forPath方法
  */
class _01CuratorTest {
    val curator = {
        val client = CuratorFrameworkFactory.builder()
            .connectString("bigdata01:2181,bigdata02:2181,bigdata03:2181")
            .retryPolicy(new ExponentialBackoffRetry(1000, 3))
            .namespace("moshang_3377")
            .build()
        //必须必须要在调用之前先start
        client.start()
        client
    }
 
    @Test
    def testGetChildren(): Unit = {
        import scala.collection.JavaConversions._
        //获取当前目录下面的所有的子节点
        val list = curator.getChildren.forPath("/")
 
        for (child <- list) {
            println(child)
        }
    }
    @Test
    def testCreated(): Unit = {
        //persist的节点
//        val path = curator.create().forPath("/second", "second".getBytes())
//        println(path)
        //创建seq节点 --ephemeral_sequential
//        val path = curator.create.withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/second", "seq".getBytes())
//        println(path)
    }
 
    @Test
    def testAlter(): Unit = {
        //zk中的修改，只可以修改节点数据
        val data = new String(curator.getData.forPath("/second"))
        println("修改前的数据：" + data)
        //修改/second的数据为100000 返回值是当前节点的最新状态数据
        val stat:Stat = curator.setData().forPath("/second", "100000".getBytes())
        if(stat != null) {
            println("修改后的数据：" + new String(curator.getData.forPath("/second")))
        }
    }
   
    @Test
    def testDelete(): Unit ={
    if(curator.checkExists().forPath("/second") != null){
      curator.delete().forPath("/second")
    }else{
      println("删除的节点不存在")
    }
  }
}

2.1Latch模式

2.1.1理论

1）竞选为Leader后，不可自行放弃领导权；
2）只能通过close方法放弃领导权；
3）强烈建议增减ConnectionStateListener，当连接SUSPENDED或者LOST时视为丢失领导权；
4）可通过await方法等待成功获取领导权，并可加入timeout；
5）可通过hasLeadership方法判断是否为Leader；
6）可通过getLeader方法获取当前Leader；
7）可通过getParticipants方法获取当前竞选Leader的参与方。

2.1.2代码示例

?:
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.leader.LeaderLatch;
import org.apache.curator.framework.recipes.leader.LeaderLatchListener;
import org.apache.curator.retry.ExponentialBackoffRetry;
 
public class LeaderLatchDemo {
    public static void main(String[] args) throws Exception {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
        CuratorFramework curator = CuratorFrameworkFactory.newClient("bigdata01:2181", retryPolicy);
 
 
        LeaderLatch leaderLatch = new LeaderLatch(curator, "/leaderlatch", "participant1");
        leaderLatch.addListener(new LeaderLatchListener() {
            @Override
            public void isLeader() {
                System.out.println("I'm the leader now");
            }
 
            @Override
            public void notLeader() {
                System.out.println("I relinquish the leadership");
            }
        });
        curator.start();
        leaderLatch.start();
        leaderLatch.await();
        System.out.println("Is leader " + leaderLatch.hasLeadership());
        System.in.read();
        System.out.println("After delete node, Is leader " + leaderLatch.hasLeadership());
        System.in.read();
        System.out.println("After delete node, Is leader " + leaderLatch.hasLeadership());
        System.in.read();
        System.out.println("After reelect node, Is leader " + leaderLatch.hasLeadership());
        leaderLatch.close();
        System.in.read();
        System.out.println("After close, Is leader " + leaderLatch.hasLeadership());
        curator.close();
        Thread.sleep(100000);
    }
}

2.2selector模式

2.2.1理论

1）竞选Leader成功后回调takeLeadership方法
2）可在takeLeadership方法中实现业务逻辑
3）一旦takeLeadership方法返回，即视为放弃领导权
4）可通过autoRequeue方法循环获取领导权
5）可通过hasLeadership方法判断是否为Leader
6）可通过getLeader方法获取当前Leader
7）可通过getParticipants方法获取当前竞选Leader的参与方

2.2.2代码示例

?:
import org.apache.curator.CuratorZookeeperClient;
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.framework.recipes.leader.Participant;
import org.apache.curator.retry.ExponentialBackoffRetry;
 
import java.util.UUID;
 
public class LeaderSelectorDemo {
    public static void main(String[] args) throws Exception {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
        CuratorFramework curator = CuratorFrameworkFactory.newClient("bigdata01:2181", retryPolicy);
 
        LeaderSelector leaderSelector = new LeaderSelector(curator, "/leaderselector", new CustomizedAdapter());
        leaderSelector.autoRequeue();
        curator.start();
        leaderSelector.start();//通过start方法发起leader竞争，竞争成功之后调用takeLeadership
 
        Thread.sleep(1000000);
        leaderSelector.close();
        curator.close();
    }
    public static class CustomizedAdapter extends LeaderSelectorListenerAdapter {
        /**
         * 竞争成功之后调用takeLeadership，当该方法执行完毕之后释放leadership
         * @param client
         * @throws Exception
         */
        @Override
        public void takeLeadership(CuratorFramework client) throws Exception {
            System.out.println("Take the leadership --> ");
            Thread.sleep(1000);
        }
    }
}