`
weitao1026
  • 浏览: 1048017 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

模拟实现一个基于zookeeper怎么解决单点故障

zookeeper 
阅读更多

模拟实现一个基于zookeeper怎么解决单点故障的案例。
单点故障问题，在分布式系统中是一个很有可能发生的场景，比如说在Hadoop2.x之前的HDFS的NameNode和MapReduce的JobTracker的单点故障，当然这个问题已经在Hadoop2.x中得到解决，解决的方式，大部分是基于Zookeeper来实现的。另外一个例子，在Hbase中的Hmaster的单点问题，也是使用Zookeeper解决的。

下面，我们先来看下，简单的实现图：




 

 

总结流程如下：

序号 描述 1 创捷父节点类型为Persistent 2 创捷子节点类型为ephemeral + sequential 3 客户端启动时创建子节点 4 序列号最小的子节点选为master，其他子节点都是slave 5 每个slave侦听序列号比它小的子节点中最大的子节点的NodeDeleted事件 6 一旦NodeDeleted事件被触发，该slave客户端会重新选定侦听对象，如果不存在可侦听对象，该slave自动晋升成master




代码，如下：

Java代码 复制代码 收藏代码
  1. package com.automicswitch;  
  2.   
  3. import java.nio.charset.Charset;  
  4. import java.nio.charset.StandardCharsets;  
  5. import java.text.SimpleDateFormat;  
  6. import java.util.Collections;  
  7. import java.util.Date;  
  8. import java.util.List;  
  9. import java.util.concurrent.CountDownLatch;  
  10.   
  11. import org.apache.zookeeper.CreateMode;  
  12. import org.apache.zookeeper.WatchedEvent;  
  13. import org.apache.zookeeper.Watcher;  
  14. import org.apache.zookeeper.ZooDefs.Ids;  
  15. import org.apache.zookeeper.ZooKeeper;  
  16. import org.apache.zookeeper.data.Stat;  
  17.   
  18. import com.util.ConnectionWatcher;  
  19.   
  20. /** 
  21.  * 模拟Zookeeper实现单点故障 
  22.  * 自动切换 
  23.  * @author  秦东亮 
  24.  *  
  25.  * ***/  
  26. public class Slave  implements  Watcher{  
  27.       
  28.     /** 
  29.      * zk实例 
  30.      * **/  
  31.     public ZooKeeper zk;  
  32.       
  33.     /** 
  34.      *  同步工具 
  35.      *  
  36.      * **/  
  37.     private CountDownLatch count=new CountDownLatch(1);  
  38.       
  39.     private static final Charset CHARSET=StandardCharsets.UTF_8;  
  40.      public Slave() {  
  41.         // TODO Auto-generated constructor stub  
  42.     }  
  43.      /** 
  44.       * hosts， 
  45.       * zookeeper的访问地址 
  46.       *  
  47.       * **/  
  48.     public Slave(String hosts) {  
  49.         try{  
  50.          zk=new ZooKeeper(hosts, 7000, new Watcher() {  
  51.               
  52.             @Override  
  53.             public void process(WatchedEvent event) {  
  54.                 // TODO Auto-generated method stub  
  55.                 if(event.getState()==Event.KeeperState.SyncConnected){  
  56.                     count.countDown();  
  57.                       
  58.                 }  
  59.                   
  60.             }  
  61.         });  
  62.         }catch(Exception e){  
  63.             e.printStackTrace();  
  64.         }  
  65.     }  
  66.     /*** 
  67.      *  
  68.      * 此方法是写入数据 
  69.      * 如果不存在此节点 
  70.      * 就会新建，已存在就是 
  71.      * 更新 
  72.      *  
  73.      * **/  
  74.         public void write(String path,String value)throws Exception{  
  75.               
  76.             Stat stat=zk.exists(path, false);  
  77.             if(stat==null){  
  78.                 zk.create(path, value.getBytes(CHARSET), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
  79.             }else{  
  80.                   
  81.                 zk.setData(path, value.getBytes(CHARSET), -1);  
  82.             }  
  83.               
  84.         }  
  85.   
  86.          public String read(String path,Watcher watch)throws Exception{  
  87.                
  88.              byte[] data=zk.getData(path, watch, null);  
  89.                
  90.                
  91.              return new String(data,CHARSET);  
  92.          }  
  93.   
  94.           SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  95.          public void automicSwitch()throws Exception{  
  96.                
  97.              System.out.println("Master故障，Slave自动切换.......,  时间  "+f.format(new Date()));  
  98.                
  99.          }  
  100.            
  101.          public void startMaster(){  
  102.                
  103.              System.out.println("A的Master 启动了........");  
  104.          }  
  105.            
  106. public void createPersist()throws Exception{  
  107.                
  108.              zk.create("/a", "主节点".getBytes(), Ids.OPEN_ACL_UNSAFE  , CreateMode.PERSISTENT);  
  109.                
  110.              System.out.println("创建主节点成功........");  
  111.                
  112.                
  113.          }  
  114.          public void createTemp()throws Exception{  
  115.                
  116.              zk.create("/a/b", "a".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);  
  117.                
  118.           System.out.println("a创建子节点成功...........");       
  119.                
  120.          }  
  121.            
  122.          public void check()throws Exception{  
  123.              List<String> list=zk.getChildren("/a", null);  
  124.               Collections.sort(list);  
  125.               if(list.isEmpty()){  
  126.                   System.out.println("此父路径下面没有节点");  
  127.               }else{  
  128.                     
  129.                   String start=list.get(0);  
  130.                     
  131.                   String data=new String(zk.getData("/a/"+start, false,null));  
  132.                   if(data.equals("a")){//等于本身就启动作为Master  
  133.                         
  134.                       if(list.size()==1){  
  135.                           startMaster();//作为Master启动  
  136.                           }else{  
  137.                               automicSwitch();  
  138.                           }  
  139.                   }else{  
  140.                       //非当前节点  
  141.                       for(int i=0;i<list.size();i++){  
  142.                           //获取那个节点存的此客户端的模拟IP  
  143.                           String temp=new String(zk.getData("/a/"+list.get(i), false, null));  
  144.                             
  145.                           if(temp.equals("a")){  
  146.                               //因为前面作为首位判断，所以这个出现的位置不可能是首位  
  147.                               //需要监听小节点里面的最大的一个节点  
  148.                               String watchPath=list.get(i-1);  
  149.                               System.out.println("a监听的是:  "+watchPath);  
  150.                                 
  151.                               zk.exists("/a/"+watchPath, this);//监听此节点的详细情况  
  152.                               break;//结束循环  
  153.                           }  
  154.                             
  155.                       }  
  156.                         
  157.                   }  
  158.                     
  159.                     
  160.               }  
  161.                
  162.          }  
  163.          public void close()throws Exception{  
  164.              zk.close();  
  165.          }  
  166.            
  167.         @Override  
  168.         public void process(WatchedEvent event) {  
  169.                
  170.             if(event.getType()==Event.EventType.NodeDeleted){  
  171.                   
  172.                 //如果发现，监听的节点，挂掉了，那么就重新，进行监听   
  173.                 try{  
  174.                 System.out.println("注意有节点挂掉，重新调整监听策略........");  
  175.                 check();  
  176.                 }catch(Exception e){  
  177.                     e.printStackTrace();  
  178.                       
  179.                 }  
  180.             }  
  181.               
  182.               
  183.               
  184.         }  
  185.       
  186.       
  187.         public static void main(String[] args)throws Exception {  
  188.               
  189.             Slave s=new Slave("10.2.143.5:2181");  
  190.             //s.createPersist();//创建主节点  
  191.             s.createTemp();  
  192.             s.check();  
  193.             Thread.sleep(Long.MAX_VALUE);  
  194.             s.close();  
  195.               
  196.         }  
  197.       
  198.   
  199. }  
package com.automicswitch;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
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.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import com.util.ConnectionWatcher;

/**
 * 模拟Zookeeper实现单点故障
 * 自动切换
 * @author  秦东亮
 * 
 * ***/
public class Slave  implements  Watcher{
	
	/**
	 * zk实例
	 * **/
	public ZooKeeper zk;
	
	/**
	 *  同步工具
	 * 
	 * **/
	private CountDownLatch count=new CountDownLatch(1);
	
	private static final Charset CHARSET=StandardCharsets.UTF_8;
	 public Slave() {
		// TODO Auto-generated constructor stub
	}
	 /**
	  * hosts，
	  * zookeeper的访问地址
	  * 
	  * **/
	public Slave(String hosts) {
		try{
		 zk=new ZooKeeper(hosts, 7000, new Watcher() {
			
			@Override
			public void process(WatchedEvent event) {
				// TODO Auto-generated method stub
				if(event.getState()==Event.KeeperState.SyncConnected){
					count.countDown();
					
				}
				
			}
		});
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	/***
	 * 
	 * 此方法是写入数据
	 * 如果不存在此节点
	 * 就会新建，已存在就是
	 * 更新
	 * 
	 * **/
		public void write(String path,String value)throws Exception{
			
			Stat stat=zk.exists(path, false);
			if(stat==null){
				zk.create(path, value.getBytes(CHARSET), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
			}else{
				
				zk.setData(path, value.getBytes(CHARSET), -1);
			}
			
		}

		 public String read(String path,Watcher watch)throws Exception{
			 
			 byte[] data=zk.getData(path, watch, null);
			 
			 
			 return new String(data,CHARSET);
		 }

		  SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		 public void automicSwitch()throws Exception{
			 
			 System.out.println("Master故障，Slave自动切换.......,  时间  "+f.format(new Date()));
			 
		 }
		 
		 public void startMaster(){
			 
			 System.out.println("A的Master 启动了........");
		 }
		 
public void createPersist()throws Exception{
			 
			 zk.create("/a", "主节点".getBytes(), Ids.OPEN_ACL_UNSAFE	, CreateMode.PERSISTENT);
			 
			 System.out.println("创建主节点成功........");
			 
			 
		 }
		 public void createTemp()throws Exception{
			 
			 zk.create("/a/b", "a".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
			 
		  System.out.println("a创建子节点成功...........");	 
			 
		 }
		 
		 public void check()throws Exception{
			 List<String> list=zk.getChildren("/a", null);
			  Collections.sort(list);
			  if(list.isEmpty()){
				  System.out.println("此父路径下面没有节点");
			  }else{
				  
				  String start=list.get(0);
				  
				  String data=new String(zk.getData("/a/"+start, false,null));
				  if(data.equals("a")){//等于本身就启动作为Master
					  
					  if(list.size()==1){
						  startMaster();//作为Master启动
						  }else{
							  automicSwitch();
						  }
				  }else{
					  //非当前节点
					  for(int i=0;i<list.size();i++){
						  //获取那个节点存的此客户端的模拟IP
						  String temp=new String(zk.getData("/a/"+list.get(i), false, null));
						  
						  if(temp.equals("a")){
							  //因为前面作为首位判断，所以这个出现的位置不可能是首位
							  //需要监听小节点里面的最大的一个节点
							  String watchPath=list.get(i-1);
							  System.out.println("a监听的是:  "+watchPath);
							  
							  zk.exists("/a/"+watchPath, this);//监听此节点的详细情况
							  break;//结束循环
						  }
						  
					  }
					  
				  }
				  
				  
			  }
			 
		 }
		 public void close()throws Exception{
			 zk.close();
		 }
		 
		@Override
		public void process(WatchedEvent event) {
			 
			if(event.getType()==Event.EventType.NodeDeleted){
				
				//如果发现，监听的节点，挂掉了，那么就重新，进行监听 
				try{
				System.out.println("注意有节点挂掉，重新调整监听策略........");
				check();
				}catch(Exception e){
					e.printStackTrace();
					
				}
			}
			
			
			
		}
	
	
		public static void main(String[] args)throws Exception {
			
			Slave s=new Slave("10.2.143.5:2181");
			//s.createPersist();//创建主节点
			s.createTemp();
			s.check();
			Thread.sleep(Long.MAX_VALUE);
			s.close();
			
		}
	

}



散仙起了，3个客户端，作为模拟Slave，本机上的一个eclipse，一个Myeclipse，和服务器上的一个Myeclipse来实现，模拟单点故障，自动切换的功能。
初始状态截图如下：




散仙停掉，2的监听后发生的变化，如下：


最后，散仙停掉A节点的Master，模拟Master宕机。





到此，散仙已经模拟实现了主从单点故障的自动切换，使用Zookeeper可以非常简单可靠的来完成这个功能，当然，我们在这里只是模拟的简单实现，真正的单点问题的实现，肯定要比散仙的这个要复杂的多，在这里只是提供给大家一个解决的思路

分享到：
| Shell脚本基础知识详细介绍
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    zookeeper伪集群

    Zookeeper是Apache Hadoop项目的一个子项目，它是一个分布式协调服务，提供高可用性、数据一致性以及分布式锁等核心功能。下面我们将深入探讨Zookeeper伪集群的配置、工作原理以及其在实际应用中的重要性。 1. **...

    ZooKeeper最新面试题2021年，常见面试题及答案汇总.md

    Chubby是由Google开发的一个分布式锁服务，类似于ZooKeeper，用于解决分布式系统的协调问题。两者之间的主要区别在于设计哲学和应用场景。Chubby更偏向于特定的应用场景，而ZooKeeper则提供了更为通用的API和功能集...

    基于redis的分布式锁实现

    - **基于Zookeeper实现** 接下来，我们将重点介绍如何利用Redis实现分布式锁。 #### 基于Redis的分布式锁实现 Redis作为一个高性能的键值存储系统，因其出色的并发性能和丰富的数据结构支持，成为了实现分布式锁...

    基于DLedger构建高可用RocketMQ集群实践.pptx

    然而，随着业务规模的扩大，Zookeeper 的单点故障问题和扩展性限制逐渐暴露。因此，RocketMQ 引入了 Raft 协议作为替代方案，以实现更高效的副本复制和领导者选举。Raft 协议相比 Zookeeper 提供了更好的可理解性和...

    Fourinone分布式计算框架

    FourInOne是高可用的，没有单点问题，可以有任意多个复本，它的复制不是定时而是基于内容变更复制，有更高的性能，FourInOne实现了领导者选举算法（但不是Paxos），在领导者服务器宕机情况下，会自动不延时的将请求...

    zookper配置搭建手册

    Zookeeper是一个高度可用的分布式协调服务框架，主要用于解决分布式应用程序中常见的数据一致性问题。它不仅能够提供基础的键值存储服务，还支持诸如命名服务、配置管理、集群管理等高级功能。Zookeeper的核心优势...

    hadoop&hbase;高可用测试环境搭建

    RegionServer也会有副本，以防止单点故障。 - **Zookeeper集群**：Zookeeper在整个Hadoop和HBase的HA中起到关键作用，用于协调节点间的通信和故障检测。 搭建步骤如下： 1. **安装和配置Hadoop** - 安装Java环境...

    Fourinone分布式并行计算四合一框架

    　Fourinone整体代码短小精悍，跟Hadoop, Zookeeper, Memcache, ActiveMq等开源产品代码上没有任何相似性，不需要任何依赖，引用一个jar包就可以嵌入式使用，良好支持window环境，可以在一台机器上模拟分布式环境，...

    storm统计单词数的demo

    【storm统计单词数的demo】是一个基于Apache Storm的入门级示例，旨在帮助初学者理解这个分布式实时计算系统的运作机制。Apache Storm是一个开源的流处理框架，它允许开发者处理无界数据流，实现高吞吐量、低延迟的...

    fourinone-3.04.25

    Fourinone整体代码短小精悍，跟Hadoop, Zookeeper, Memcache, ActiveMq等开源产品代码上没有任何相似性，不需要任何依赖，引用一个jar包就可以嵌入式使用，良好支持window环境，可以在一台机器上模拟分布式环境，更...

    云计算发作业之Hadoop的安装与配置

    单机模式主要用于开发和测试环境，而伪分布式模式则模拟了一个具有单点故障的集群环境。在Hadoop 2.7.4的安装过程中，需要下载hadoop-2.7.4.tar.gz并解压到指定目录，之后通过配置hadoop-env.sh文件来指定JAVA_HOME...

    华为认证考试大数据模拟试题60道含答案-HCIA-Big-Data.docx

    因此，HDFS存在单点故障问题。 ##### 8. 元数据的持久化 - **知识点**：元数据持久化是指将暂存于内存中的元数据信息保存到持久化的存储设备（如磁盘）的过程，确保数据的安全性和持久性。 ##### 9. Hive的适用...

    1000道 互联网Java工程师面试题 485页

    - **伪集群模式**：在一个主机上启动多个Zookeeper实例，模拟集群环境。 - **集群模式**：多台主机部署多个Zookeeper实例，形成真正的集群。 #### 20、集群最少要几台机器，集群规则是怎样的? - **最少机器数**：3...

    1000道 互联网Java工程师面试题 485页_PDF密码解除.pdf

    - **分布式协调服务：**ZooKeeper是一个分布式的协调服务，用于管理和协调分布式应用中的进程。 - **数据一致性：**保证分布式环境中数据的一致性。 - **集群管理：**帮助实现故障转移、选举主节点等功能。 **2. ...

    Java 分布式应用程序设计

    - 两阶段提交（2PC）：经典的分布式事务解决方案，但存在单点故障和性能问题。 - TCC（Try-Confirm-Cancel）：补偿型事务模型，每个操作都有尝试、确认和取消三部分。 - Saga：长事务模型，将大事务拆分为一系列...

    storm demo

    【storm demo】是一个基于Apache Storm的实践项目，旨在教授如何运用Storm的核心组件——Spout、Bolt和Topology来构建实时数据处理系统。Apache Storm是一个开源的分布式实时计算系统，能够处理大量的流数据，并保证...

    Win10编译好的hadoop2.7.6

    2. HA（High Availability）：Hadoop 2.7.6支持NameNode的高可用性，通过使用两个活动/备用NameNode来避免单点故障。 3. Federation：Hadoop 2.7.6引入了NameNode Federation，允许多个独立的命名空间并行运行，...

    Dubbo测试

    5. **容错与故障模拟测试**：通过模拟网络故障、服务宕机等情况，测试Dubbo的重试、熔断、降级等机制。 6. **服务注册与发现测试**：验证服务是否能正确注册到注册中心（如Zookeeper、Eureka），消费者是否能正确...

    Hadoop 2.7.6 呕心沥血制作，100分不多

    - **可靠性增强**：通过HA机制可以有效避免单点故障问题，提高系统的稳定性和可靠性。 - **服务连续性**：当主Namenode出现故障时，能够快速切换到备用Namenode，确保业务不中断。 - **管理便捷性**：通过Zookeeper...

    最新Hadoop的面试题总结

    - 伪分布式模式：在一个节点上模拟多节点集群，所有Hadoop组件都在同一台机器上运行，但数据是分布存储的。 - 完全分布式模式：真正的多节点集群，每个节点运行不同的Hadoop服务，如NameNode、DataNode等。 2. **...

Magicbox
Global site tag (gtag.js) - Google Analytics