Zookeeper架构与原理

Zookeeper的特点：

• 最终一致性：为客户端展示同一视图，这是zookeeper最重要的功能。
• 可靠性：如果消息被到一台服务器接受，那么它将被所有的服务器接受。
• **非实时性：**Zookeeper不能保证两个客户端能同时得到刚更新的数据，如果需要最新数据，应该在读数据之前调用sync()接口。
• 等待无关（wait-free）：慢的或者失效的client不干预快速的client的请求。
• 原子性：更新只能成功或者失败，没有中间状态。
• 顺序性：所有Server，同一消息发布顺序一致。

1. 安装与配置

Linux 下的启动脚本是 zkServer.sh；Zookeeper 的配置文件在 conf 目录下，这个目录下有 zoo_sample.cfg 和 log4j.properties，你需要做的就是将 zoo_sample.cfg 改名为 zoo.cfg：

tickTime=2000 
dataDir=D:/devtools/zookeeper-3.2.2/build 
clientPort=2181

• tickTime：这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。
• dataDir：顾名思义就是 Zookeeper 保存数据的目录，默认情况下，Zookeeper 将写数据的日志文件也保存在这个目录里。
• clientPort：这个端口就是客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求。

1.1 集群模式

zoo.cfg：

initLimit=5 
syncLimit=2 
server.1=192.168.211.1:2888:3888 
server.2=192.168.211.2:2888:3888

• initLimit：Follower初始连接到Leader时能忍受的最长心跳间隔数（initLimit * tickTime）；
• syncLimit： Leader 与 Follower 之间发送消息，请求和应答的最长时延（syncLimit * tickTime）；
• server.A=B：C：D：
  
  • 其中 A 是一个数字，表示这个是第几号服务器；
  • B 是这个服务器的 ip 地址；
  • C 与Leader 交换信息的端口；
  • D 选举通信的端口；

---

2. 基本架构

2.1 数据同步

整个集群完成Leader选举后，Learner会向Leader进行注册，当Learner向Leader完成注册后，就进入数据同步环节，同步过程就是Leader将那些没有在Learner服务器上提交过的事务请求同步给Learner服务器，大体过程如下:

对于集群数据同步而言，通常分为四类，直接差异化同步(DIFF同步)、先回滚再差异化同步(TRUNC+DIFF同步)、仅回滚同步(TRUNC同步)、全量同步(SNAP同步)，在初始化阶段，Leader会优先以全量同步方式来同步数据。同时，会根据Leader和Learner之间的数据差异情况来决定最终的数据同步方式。

2.2 数据一致性

ZooKeeper通过复制来实现高可用性，只要集合体中半数以上的机器处于可用状态，它就能够提供服务。例如，在一个有5个节点的集合体中，每个Follower节点的数据都是Leader节点数据的副本，也就是说我们的每个节点的数据视图都是一样的，这样就可以有五个节点提供ZooKeeper服务。并且集合体中任意2台机器出现故障，都可以保证服务继续，因为剩下的3台机器超过了半数。

从概念上来说，ZooKeeper它所做的就是确保对Znode树的每一个修改都会被复制到集合体中超过半数的机器上，客户端可以连接任意ZooKeeper服务节点来读写数据。如果少于半数的机器出现故障，则最少有一台机器会保存最新的状态，那么这台机器就是我们的Leader。其余的副本最终也会更新到这个状态。如果 Leader挂了，由于其他机器保存了Leader的副本，那就可以从中选出一台机器作为新的Leader继续提供服务。

Zookeeper使用简单的同步策略，通过以下两条基本保证来实现数据的一致性：

① 全局串行化所有的写操作；

② 保证同一客户端的指令被FIFO执行（以及消息通知的FIFO）；

所有的读请求由Zk Server 本地响应，所有的更新请求将转发给Leader，由Leader实施。

2.3 ZooKeeper写流程

1. 客户端首先和一个Server或者Observe（可以认为是一个Server的代理）通信，发起写请求；
2. 然后Server将写请求转发给Leader；
3. Leader再将写请求转发给其他Server；
4. Server在接收到写请求后写入数据并响应Leader；
5. Leader在接收到大多数写成功回应后，认为数据写成功，响应Server；
6. 由当初提交写请求的Server响应Client。

---

3. 常用接口列表

客户端要连接 Zookeeper 服务器可以通过创建 org.apache.zookeeper. ZooKeeper 的一个实例对象，然后调用这个类提供的接口来和服务器交互。

3.1 接口

（1）String create(String path, byte[] data, List acl, CreateMode createMode)

创建一个给定的目录节点 path, 并给它设置数据，CreateMode 标识有四种形式的目录节点，分别是：

• PERSISTENT：持久化目录节点，这个目录节点存储的数据不会丢失；
• PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名；
• EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是 session 超时，这种节点会被自动删除；
• EPHEMERAL_SEQUENTIAL：临时自动编号节点。

（2）void delete(String path, int version)

删除 path 对应的目录节点，version 为 -1 可以匹配任何版本，也就删除了这个目录节点所有数据。

（3）List getChildren(String path, boolean watch)

获取指定 path 下的所有子目录节点，同样 getChildren方法也有一个重载方法可以设置特定的 watcher 监控子节点的状态。

（4）Stat exists(String path, boolean watch)

判断某个 path 是否存在，并设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper 实例时指定的 watcher，exists方法还有一个重载方法，可以指定特定的 watcher：

Statexists(String path, Watcher watcher)

（5）Stat setData(String path, byte[] data, int version)

给 path 设置数据，可以指定这个数据的版本号，如果 version 为 -1 怎可以匹配任何版本。

（6）byte[] getData(String path, boolean watch, Stat stat)

获取这个 path 对应的目录节点存储的数据，数据的版本等信息可以通过 stat 来指定，同时还可以设置是否监控这个目录节点数据的状态。

（7）Stat setACL(String path, List acl, int version)

给某个目录节点重新设置访问权限，需要注意的是 Zookeeper 中的目录节点权限不具有传递性，父目录节点的权限不能传递给子目录节点。目录节点 ACL 由两部分组成：perms 和 id。
Perms 有 ALL、READ、WRITE、CREATE、DELETE、ADMIN 几种
而 id 标识了访问目录节点的身份列表，默认情况下有以下两种：
ANYONE_ID_UNSAFE = new Id(“world”, “anyone”) 和 AUTH_IDS = new Id(“auth”, “”) 分别表示任何人都可以访问和创建者拥有访问权限。

3.2 基本操作演示

// 创建一个与服务器的连接
ZooKeeper zk = new ZooKeeper("localhost:" + CLIENT_PORT, 
       ClientBase.CONNECTION_TIMEOUT, new Watcher() { 
           // 监控所有被触发的事件
           public void process(WatchedEvent event) { 
               System.out.println("已经触发了" + event.getType() + "事件！"); 
           } 
       }); 

// 创建一个目录节点
zk.create("/testRootPath", "testRootData".getBytes(), Ids.OPEN_ACL_UNSAFE,
  CreateMode.PERSISTENT); 

// 创建一个子目录节点
zk.create("/testRootPath/testChildPathOne", "testChildDataOne".getBytes(),
  Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
System.out.println(new String(zk.getData("/testRootPath",false,null))); 

// 取出子目录节点列表
System.out.println(zk.getChildren("/testRootPath",true)); 

// 修改子目录节点数据
zk.setData("/testRootPath/testChildPathOne","modifyChildDataOne".getBytes(),-1); 
System.out.println("目录节点状态：["+zk.exists("/testRootPath",true)+"]"); 

// 创建另外一个子目录节点
zk.create("/testRootPath/testChildPathTwo", "testChildDataTwo".getBytes(), 
  Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
System.out.println(new String(zk.getData("/testRootPath/testChildPathTwo",true,null))); 

// 删除子目录节点
zk.delete("/testRootPath/testChildPathTwo",-1); 
zk.delete("/testRootPath/testChildPathOne",-1); 

// 删除父目录节点
zk.delete("/testRootPath",-1); 

// 关闭连接
zk.close();

---

4. 应用场景

4.1 监控服务器状态

EPHEMERAL节点 + getChildren操作

它们的实现方式都是在 Zookeeper 上创建一个 EPHEMERAL 类型的目录节点，然后每个 Server 在它们创建目录节点的父目录节点上调用 getChildren(String path, boolean watch) 方法并设置 watch 为 true，由于是 EPHEMERAL 目录节点，当创建它的 Server 死去，这个目录节点也随之被删除，所以 Children 将会变化，这时 getChildren上的 Watch 将会被调用，所以其它 Server 就知道已经有某台 Server 死去了。新增 Server 也是同样的原理。

---

4.2 Leader选举

EPHEMERAL_SEQUENTIAL节点，选最小编号的节点作为Leader/Master

每台 Server 创建一个 EPHEMERAL_SEQUENTIAL 目录节点，选择当前是最小编号的 Server 为 Master。

假如这个最小编号的 Server 死去，由于是 EPHEMERAL 节点，死去的 Server 对应的节点也被删除，所以当前的节点列表中又出现一个最小编号的节点，我们就选择这个节点为当前 Master。

这样就实现了动态选择 Master，避免了传统意义上单 Master 容易出现单点故障的问题。

---

4.3 分布式锁

需要获得锁的 Server 创建一个 EPHEMERAL_SEQUENTIAL 目录节点，然后调用 getChildren方法获取当前的目录节点列表中最小的目录节点是不是就是自己创建的目录节点，如果正是自己创建的，那么它就获得了这个锁，如果不是那么它就调用 exists(String path, boolean watch) 方法并监控 Zookeeper 上目录节点列表的变化，一直到自己创建的节点是列表中最小编号的目录节点，从而获得锁，释放锁很简单，只要删除前面它自己所创建的目录节点就行了。

---

4.4 分布式FIFO队列

实现的思路也非常简单，就是在特定的目录下创建 SEQUENTIAL 类型的子目录 /queue_i，这样就能保证所有成员加入队列时都是有编号的，出队列时通过 getChildren( ) 方法可以返回当前所有的队列中的元素，然后消费其中最小的一个，这样就能保证 FIFO。

生产者代码：

boolean produce(int i) throws KeeperException, InterruptedException{ 
       ByteBuffer b = ByteBuffer.allocate(4); 
       byte[] value; 
       b.putInt(i); 
       value = b.array(); 
       zk.create(root + "/element", value, ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                   CreateMode.PERSISTENT_SEQUENTIAL); 
       return true; 
   }

消费者代码：

int consume() throws KeeperException, InterruptedException{ 
       int retvalue = -1; 
       Stat stat = null; 
       while (true) { 
           synchronized (mutex) { 
               List<String> list = zk.getChildren(root, true); 
               if (list.size() == 0) { 
                   mutex.wait(); 
               } else { 
                   Integer min = new Integer(list.get(0).substring(7)); 
                   for(String s : list){ 
                       Integer tempValue = new Integer(s.substring(7)); 
                       if(tempValue < min) min = tempValue; 
                   } 
                   byte[] b = zk.getData(root + "/element" + min,false, stat); 
                   zk.delete(root + "/element" + min, 0); 
                   ByteBuffer buffer = ByteBuffer.wrap(b); 
                   retvalue = buffer.getInt(); 
                   return retvalue; 
               } 
           } 
       } 
}

---