当前位置:首页 > 开发 > 互联网 > 正文

Zookeeper学习笔记一

发表于: 2015-07-06   作者:zh-workhard-Java   来源:转载   浏览:
摘要: 1.前言               由于在开发产品的过程中接触到了Zookeeper,业余时间学习并开发了一个利用Zookeeper实现分布式锁的实例。   2.Zookeeper简介        大家对于分布式架构,可能比较熟悉Hadoop,而Zookee

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: []  

Zookeeper学习笔记一

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
最近在工作中,为了完善公司集群服务的架构,提高可用性,降低运维成本,因此开始学习ZooKeeper。
ZooKeeper是什么? 高可用的高性能的分布式系统协调服务。局部不可用是分布式系统的固有特征,ZooKe
zookeeper功能点: 统一命名空间(Name Service) 配置推送 (Watch) 集群管理(Group membership) 统一
Unlike a typical file system, which is designed for storage, ZooKeeper data is kept in-memory
http://blog.csdn.net/shirdrn/article/details/7183503 参照前公司的目录结构组织dubbo应用的环境
基本是 http://zookeeper.apache.org/doc/trunk/zookeeperOver.html 的翻译,应用场景摘抄:http://
虽然了解ZooKeeper的锁有一段时间了,但也只是到了会用的一个程度,其原理也大概知道是怎么一回事,
众所周知,在Java开发中,要创建一个单进程锁非常简单,使用JDK中自带的java.util.concurrent.locks
在前面的文章里我多次提到zookeeper对于分布式系统开发的重要性,因此对zookeeper的学习是非常必要
Zookeeper的会话状态变迁图: Connection Loss: CONNECTION_LOSS意味着客户端和服务器端的连接断开
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号