Zookeeper学习笔记一

ahua671

　　1.前言       
　　由于在开发产品的过程中接触到了Zookeeper，业余时间学习并开发了一个利用Zookeeper实现分布式锁的实例。
　　2.Zookeeper简介
　　大家对于分布式架构，可能比较熟悉Hadoop，而Zookeeper是Hadoop的一个子项目。Zookeeper本身包含一个简单的原语集，并且是一个分布式的、开源的应用程序协调服务架构。分布式应用程序可以基于Zookeeper实现同步服务、配置维护和命令服务等功能。
　　之所以在分布式的应用程序中采用Zookeeper，是因为在大型的应用项目开发的过程中，开发人员不能很好地使用锁机制，并且在某些应用中不适合使用基于消息的协调机制。而Zookeeper可以提供一种可靠地、可扩展地、分布式地、可配置地协调机制来统一管理系统的状态。因此，为了解决上述问题，选择了Zookeeper。
　　3.Zookeeper原理简单分析
　　a.角色——Zookeeper中主要的角色包括三类：
　　Leader（领导者），负责进行投票的发起和决议（更新系统状态）；
　　Learner（学习者），包括Follower（跟随者）和Observer（观察者）两种，其中Follower负责接收客户端请求并将结果返回给客户端，并且在选主过程中参与投票，Observer负责接收客户端连接，将写请求转发给Leader节点，但是Observer不参与投票过程，只同步Leader的状态，之所以有Observer这样一种角色其目的是为了扩展系统，提供读取速度。   
　　Client（客户端） ：作为请求的发起方。
　　b.系统模型图——见附件
　　附件中这样设计的原因如下：
　　最终一致性：client不论连接到哪个Server，展示给它都是同一个视图，这是zookeeper最重要的性能。
　　可靠性：具有简单、健壮、良好的性能，如果消息m被到一台服务器接受，那么它将被所有的服务器接受。
　　实时性：Zookeeper保证客户端将在一个时间间隔范围内获得服务器的更新信息，或者服务器失效的信息。但由于网络延时等原因，Zookeeper不能保证两个客户端能同时得到刚更新的数据，如果需要最新数据，应该在读数据之前调用sync()接口。
　　等待无关（wait-free）：慢的或者失效的client不得干预快速的client的请求，使得每个client都能有效的等待。
　　原子性：更新只能成功或者失败，没有中间状态。
　　顺序性：包括全局有序和偏序两种：全局有序是指如果在一台服务器上消息a在消息b前发布，则在所有Server上消息a都将在消息b前被发布；偏序是指如果一个消息b在消息a后被同一个发送者发布，
　　a必将排在b前面。
　　d.工作原理
　　Zookeeper的核心是原子广播，这个机制保证了各个Server之间的同步。实现这个机制的协议叫做Zab协议。Zab协议有两种模式，它们分别是恢复模式（选主）和广播模式（同步）。当服务启动或者在领导者崩溃后，Zab就进入了恢复模式，当领导者被选举出来，且大多数Server完成了和leader的状态同步以后，恢复模式就结束了。状态同步保证了leader和Server具有相同的系统状态。
　　为了保证事务的顺序一致性，zookeeper采用了递增的事务id号（zxid）来标识事务。所有的提议（proposal）都在被提出的时候加上了zxid。实现中zxid是一个64位的数字，它高32位是epoch用来标识leader关系是否改变，每次一个leader被选出来，它都会有一个新的epoch，标识当前属于那个leader的统治时期。低32位用于递增计数。
　　每个Server在工作过程中有三种状态：
　　LOOKING：当前Server不知道leader是谁，正在搜寻
　　LEADING：当前Server即为选举出来的leader
　　FOLLOWING：leader已经选举出来，当前Server与之同步
　　e.选主流程
　　当leader崩溃或者leader失去大多数的follower，这时候zk进入恢复模式，恢复模式需要重新选举出一个新的leader，让所有的Server都恢复到一个正确的状态。Zk的选举算法有两种：一种是基于basic paxos实现的，另外一种是基于fast paxos算法实现的。系统默认的选举算法为fast paxos。
　　先介绍basic paxos流程：选举线程由当前Server发起选举的线程担任，其主要功能是对投票结果进行统计，并选出推荐的Server；
　　选举线程首先向所有Server发起一次询问(包括自己)；
　　选举线程收到回复后，验证是否是自己发起的询问(验证zxid是否一致)，然后获取对方的id(myid)，并存储到当前询问对象列表中，最后获取对方提议的leader相关信息(id,zxid)，并将这些信息存储到当次选举的投票记录表中；
　　收到所有Server回复以后，就计算出zxid最大的那个Server，并将这个Server相关信息设置成下一次要投票的Server；
　　线程将当前zxid最大的Server设置为当前Server要推荐的Leader，如果此时获胜的Server获得n/2 + 1的Server票数， 设置当前推荐的leader为获胜的Server，将根据获胜的Server相关信息设置自己的状态，否则，继续这个过程，直到leader被选举出来。
　　通过流程分析我们可以得出：要使Leader获得多数Server的支持，则Server总数必须是奇数2n+1，且存活的Server的数目不得少于n+1。
　　每个Server启动后都会重复以上流程。在恢复模式下，如果是刚从崩溃状态恢复的或者刚启动的server还会从磁盘快照中恢复数据和会话信息，zk会记录事务日志并定期进行快照，方便在恢复时进行状态恢复。
　　fast paxos流程是在选举过程中，某Server首先向所有Server提议自己要成为leader，当其它Server收到提议以后，解决epoch和zxid的冲突，并接受对方的提议，然后向对方发送接受提议完成的消息，重复这个流程，最后一定能选举出Leader。
　　f.同步流程
　　选完leader以后，zk就进入状态同步过程：
　　leader等待server连接；
　　Follower连接leader，将最大的zxid发送给leader；
　　Leader根据follower的zxid确定同步点；
　　完成同步后通知follower 已经成为uptodate状态；
　　Follower收到uptodate消息后，又可以重新接受client的请求进行服务了。
　　g.Leader工作流程
　　Leader主要有三个功能：
　　恢复数据；
　　维持与Learner的心跳，接收Learner请求并判断Learner的请求消息类型；
　　Learner的消息类型主要有PING消息、REQUEST消息、ACK消息、REVALIDATE消息，根据不同的消息类型，进行不同的处理。（PING消息是指Learner的心跳信息；REQUEST消息是Follower发送的提议信息，包括写请求及同步请求；ACK消息是Follower的对提议的回复，超过半数的Follower通过，则commit该提议；REVALIDATE消息是用来延长SESSION有效时间。）
　　h.Follower工作流程
　　Follower主要有四个功能：
　　向Leader发送请求（PING消息、REQUEST消息、ACK消息、REVALIDATE消息）；
　　接收Leader消息并进行处理；
　　接收Client的请求，如果为写请求，发送给Leader进行投票；
　　返回Client结果。
　　Follower的消息循环处理如下几种来自Leader的消息：
　　PING消息： 心跳消息；
　　PROPOSAL消息：Leader发起的提案，要求Follower投票；
　　COMMIT消息：服务器端最新一次提案的信息；
　　UPTODATE消息：表明同步完成；
　　REVALIDATE消息：根据Leader的REVALIDATE结果，关闭待revalidate的session还是允许其接受消息；
　　SYNC消息：返回SYNC结果到客户端，这个消息最初由客户端发起，用来强制得到最新的更新。
　　对于observer的流程不再叙述，Observer流程和Follower的唯一不同的地方就是Observer不会参加leader发起的投票。
　　3.应用场景
　　说了这么多的理论知识，下面通过一个实例：利用Zookeeper实现互斥锁：

package com.zh.learn.zookeeper;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
/**
* 以一个DistributedClient对象模拟一个进程的形式, 演示zookeeper分布式锁的实现
*/
public class DistributedClient {  
// 超时时间  
private static final int SESSION_TIMEOUT = 5000;
// zookeeper server列表  
private String hosts = "localhost:4180,localhost:4181,localhost:4182";  
private String groupNode = "locks";  
private String subNode = "sub";  
private ZooKeeper zk;
// 当前client创建的子节点  
private String thisPath;
// 当前client等待的子节点  
private String waitPath;  
private CountDownLatch latch = new CountDownLatch(1);  
/**
* 连接zookeeper
*/
public void connectZookeeper() throws Exception{
zk = new ZooKeeper(hosts, SESSION_TIMEOUT,
new Watcher(){
public void process(WatchedEvent event) {  
try{
//连接建立时, 打开latch, 唤醒wait在该latch上的线程  
if (event.getState() == KeeperState.SyncConnected) {  
latch.countDown();  
}
//发生了waitPath的删除事件  
if (event.getType() == EventType.NodeDeleted && event.getPath().equals(waitPath)) {  
// 确认thisPath是否真的是列表中的最小节点  
List<String> childrenNodes = zk.getChildren("/" + groupNode, false);  
String thisNode = thisPath.substring(("/" + groupNode + "/").length());  
// 排序  
Collections.sort(childrenNodes);  
int index = childrenNodes.indexOf(thisNode);  
if (index == 0) {  
// 确实是最小节点  
doSomething();  
} else {  
// 说明waitPath是由于出现异常而挂掉的  
// 更新waitPath  
waitPath = "/" + groupNode + "/" + childrenNodes.get(index - 1);  
// 重新注册监听, 并判断此时waitPath是否已删除  
if (zk.exists(waitPath, true) == null) {  
doSomething();  
}  
}  
}
}catch(Exception e){
e.printStackTrace();
}
}
}
);
// 等待连接建立  
latch.await();  
// 创建子节点  
thisPath = zk.create("/" + groupNode + "/" + subNode, null, Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);  
// wait一小会, 让结果更清晰一些  
Thread.sleep(10);  
// 注意, 没有必要监听"/locks"的子节点的变化情况  
List<String> childrenNodes = zk.getChildren("/" + groupNode, false);
// 列表中只有一个子节点, 那肯定就是thisPath, 说明client获得锁  
if (childrenNodes.size() == 1) {  
doSomething();  
} else {  
String thisNode = thisPath.substring(("/" + groupNode + "/").length());  
// 排序  
Collections.sort(childrenNodes);  
int index = childrenNodes.indexOf(thisNode);  
if (index == -1) {  
// never happened  
} else if (index == 0) {  
// inddx == 0, 说明thisNode在列表中最小, 当前client获得锁  
doSomething();  
} else {  
// 获得排名比thisPath前1位的节点  
this.waitPath = "/" + groupNode + "/" + childrenNodes.get(index - 1);  
// 在waitPath上注册监听器, 当waitPath被删除时, zookeeper会回调监听器的process方法  
zk.getData(waitPath, true, new Stat());  
}  
}
}
private void doSomething() throws Exception {  
try {  
System.out.println("gain lock: " + thisPath);  
Thread.sleep(2000);  
// do something  
} finally {  
System.out.println("finished: " + thisPath);  
// 将thisPath删除, 监听thisPath的client将获得通知  
// 相当于释放锁  
zk.delete(this.thisPath, -1);  
}  
}  
public static void main(String[] args) throws Exception {  
for (int i = 0; i < 10; i++) {  
new Thread() {  
public void run() {  
try {  
DistributedClient dl = new DistributedClient();  
dl.connectZookeeper();  
} catch (Exception e) {  
e.printStackTrace();  
}  
}  
}.start();  
}  
Thread.sleep(Long.MAX_VALUE);  
}  
}   

package com.zh.learn.zookeeper;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.CreateMode;
public class AppServer {  
private String groupNode = "sgroup";  
private String subNode = "sub";
private String hosts = "localhost:4180,localhost:4181,localhost:4182" ;
private int time = 5000 ;
/**
* 连接zookeeper
* @param address server的地址
*/  
public void connectZookeeper(String address) throws Exception {  
ZooKeeper zk = new ZooKeeper(hosts, time, new Watcher() {
@Override
public void process(WatchedEvent arg0) {
// TODO Auto-generated method stub
}
});
// 在"/sgroup"下创建子节点  
// 子节点的类型设置为EPHEMERAL_SEQUENTIAL, 表明这是一个临时节点, 且在子节点的名称后面加上一串数字后缀  
// 将server的地址数据关联到新创建的子节点上  
String createdPath = zk.create("/" + groupNode + "/" + subNode, address.getBytes("utf-8"),   
Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);  
System.out.println("create: " + createdPath);  
}  
/**
* server的工作逻辑写在这个方法中
* 此处不做任何处理, 只让server sleep
*/  
public void handle() throws InterruptedException {  
Thread.sleep(Long.MAX_VALUE);  
}  
public static void main(String[] args) throws Exception {  
// 在参数中指定server的地址  
if (args.length == 0) {  
System.err.println("The first argument must be server address");  
System.exit(1);  
}  
AppServer as = new AppServer();  
as.connectZookeeper(args[0]);  
as.handle();  
}  
}  
　　将其打成appserver.jar；

package com.zh.learn.zookeeper;
import java.util.ArrayList;
import java.util.List;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
public class AppClient {  
private String groupNode = "sgroup";  
private ZooKeeper zk;  
private Stat stat = new Stat();  
private volatile List<String> serverList;  
/**
* 连接zookeeper
*/  
public void connectZookeeper() throws Exception {  
zk = new ZooKeeper("localhost:4180,localhost:4181,localhost:4182", 5000,
new Watcher() {
public void process(WatchedEvent event) {  
// 如果发生了"/sgroup"节点下的子节点变化事件, 更新server列表, 并重新注册监听  
if (event.getType() == EventType.NodeChildrenChanged   
&& ("/" + groupNode).equals(event.getPath())) {  
try {  
updateServerList();  
} catch (Exception e) {  
e.printStackTrace();  
}  
}  
}
});  
updateServerList();  
}  
/**
* 更新server列表
*/  
private void updateServerList() throws Exception {  
List<String> newServerList = new ArrayList<String>();  
// 获取并监听groupNode的子节点变化  
// watch参数为true, 表示监听子节点变化事件.   
// 每次都需要重新注册监听, 因为一次注册, 只能监听一次事件, 如果还想继续保持监听, 必须重新注册  
List<String> subList = zk.getChildren("/" + groupNode, true);  
for (String subNode : subList) {  
// 获取每个子节点下关联的server地址  
byte[] data = zk.getData("/" + groupNode + "/" + subNode, false, stat);  
newServerList.add(new String(data, "utf-8"));  
}  
// 替换server列表  
serverList = newServerList;  
System.out.println("server list updated: " + serverList);  
}  
/**
* client的工作逻辑写在这个方法中
* 此处不做任何处理, 只让client sleep
*/  
public void handle() throws InterruptedException {  
Thread.sleep(Long.MAX_VALUE);  
}  
public static void main(String[] args) throws Exception {  
AppClient ac = new AppClient();  
ac.connectZookeeper();  
ac.handle();  
}  
}  
　　将其打包成appclient.jar
　　    运行结果：
　　    在运行jar包之前, 需要确认zookeeper中是否已经存在"/sgroup"节点了, 没有不存在, 则创建该节点. 如果存在, 最好先将其删除, 然后再重新创建. ZooKeeper的相关命令可参考我的另一篇博文. 
　　运行appclient.jar:  java -jar appclient.jar 开启多个命令行窗口, 每个窗口运行appserver.jar进程: java -jar appserver.jar server0000. "server0000"表示server的地址, 别忘了给每个server设定一个不同的地址. 观察appclient的输出. 
　　依次结束appserver的进程, 观察appclient的输出. 
　　appclient的输出类似于:
　　 
　　server list updated: []  
　　server list updated: [server0000]  
　　server list updated: [server0000, server0001]  
　　server list updated: [server0000, server0001, server0002]  
　　server list updated: [server0000, server0001, server0002, server0003]  
　　server list updated: [server0000, server0001, server0002]  
　　server list updated: [server0000, server0001]  
　　server list updated: [server0000]  
　　server list updated: []