ZooKeeper分布式队列实现MapReduce任务集成

最新推荐文章于 2023-11-20 16:16:15 发布
最新推荐文章于 2023-11-20 16:16:15 发布
阅读量965 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiushuichangtian888/article/details/78484678
版权
          随着Hadoop的普及，越来越多的公司在构建自己的Hadoop的集群，一赶大数据不可阻挡之趋势，虽然大数据的发展的确是不可阻挡的。随着业务的延展，有时候公司内部不同部门或团队之间就会出现归属自己的Hadoop集群，这种多集群的方式，既让不同业务板块的Hadoop集群实现个性化、差异化，以更好的为自身业务场景所服务，与此同时也会不可避免的出现需要协调多个Hadoop集群共同完成某件任务的场景。下面我们以公司经营利润的计算为例来说明。
需求说明 ：
          公司一年经营利润的计算，需要由采购团队计算采购的支出( purchase )，销售团队计算销售的收入( sell )，然后还包括其他部门费用支付的计算(other)，则：
一年的：
             利润（ profit ）=销售收入-采购支出-其他业务花费， 我们暂且将业务场景定义的如此简单。
          从系统角度来看，采购部门要统计采购数据(海量数据)，销售部门统计销售数据((海量数据)，其他部门统计的其他费用支出(汇总的少量数据)，最后系统计算得到当月的利润。
这里要说明的是，采购系统是单独的系统，销售是另外单独的系统，及以其他很多大大小小的系统，如何能让多个系统，配合起来做这道计算题呢？？
          计算方式我们采用基础的MapReduce进行，则 profit 的计算需要 purchase、 sell、 other三个任务同时完成后，才能触发。我们此处探索，使用ZooKeeper来进行任务的协调，当然还有其他很好的方式比如，使用消息总线或者 Oozie等工具。
     
架构设计：
  1. 数据存储：
  • 采购数据，为海量数据，基于Hadoop存储和分析；
  • 销售数据，为海量数据，基于Hadoop存储和分析；
  • 其他费用支出，为少量数据，基于文件或数据库存储和分析；
     2.程序设计：
设计一个同步队列，这个队列有3个条件节点，分别对应采购(purchase)，销售(sell)，其他费用(other)3个部分。当3个节点都被创建后，程序会自动触发计算利润，并创建利润(profit)节点。上面3个节点的创建，无顺序要求。每个节点只能被创建一次：


           说明 ：
  • 2个独立的Hadoop集群
  • 2个独立的Java应用
  • 3个Zookeeper集群几点
              
            /queue是队列的目录;
            /queue/purchase是队列的采购排队节点，对应Hadoop App1完成任务后在ZK上创建；
              /queue/sell 是队列的销售排队节点，对应Hadoop App2完成计算后在ZK上创建；
             /queue/other 是队列的其他费用节点，对应Java程序 App3完成计算后在ZK上创建；
              /queue/profit是队列的利润节点，当前三个节点都创建成功后，触发该节点的创建，完成利润计算；

             创建/queue/purchase,/queue/sell,/queue/other目录时，没有前后顺序，程序提交后，/queue目录下会生成对应该子目录；
                /queue/profit被创建后，zk的应用会监听到这个事件，通知应用，队列已完成。
               (PS：向下的红色箭头代表，利润节点创建完成后，删除业务几点zk1、zk2、zk3释放对应Hadoop计算节点资源)

        3.实验环境：
          开发环境： Win7 64bit、JDK1.6、Maven3、Eclipse Luna；
            Zookeeper服务器：三台服务器几点，CentOS 6.5、 zookeeper-3.4.5、JDK1.6    
          Hadoop集群：   CentOS 6.5、JDK1.6、Hadoop-1.2.1
         提前完成Hadoop集群和Zookeep集群的搭建，并启动；  

        4.实验数据：
  • 采购数据：purchase.csv，格式示例：
              一共4列，分别对应 产品ID,产品数量,产品单价,采购日期，
1,26,1168,2013-01-08
2,49,779,2013-02-12
3,80,850,2013-02-05
4,69,1585,2013-01-26
5,88,1052,2013-01-13
6,84,2363,2013-01-19
7,64,1410,2013-01-12
8,53,910,2013-01-11
9,21,1661,2013-01-19
10,53,2426,2013-02-18
  • 销售数据：sell.csv，格式示例：
一共4列，分别对应 产品ID,销售数量,销售单价,销售日期 ,
1,14,1236,2013-01-14
2,19,808,2013-03-06
3,26,886,2013-02-23
4,23,1793,2013-02-09
5,27,1206,2013-01-21
6,27,2648,2013-01-30
7,22,1502,2013-01-19
8,20,1050,2013-01-18
9,13,1778,2013-01-30
10,20,2718,2013-03-14
                其他费用数据集： other.csv，格式示例：
               一共2列，分别对应 发生日期，发生金额
2013-01-02,552
2013-01-03,1092
2013-01-04,1794
2013-01-05,435
2013-01-06,960
2013-01-07,1066
2013-01-08,1354
2013-01-09,880
2013-01-10,1992
2013-01-11,931
5. 程序开发：
  • 使用Maven构建Java Project，myZookeeper，目录机构如下：
     

  •   项目使用Maven进行依赖包的管理，pom.xml文件引入：
    < dependencies >
            < dependency >
                 < groupId > org.apache.hadoop </ groupId >
                 < artifactId > hadoop -core </ artifactId >
                 < version > 1.2.1 </ version >
            </ dependency >
            < dependency >
                 < groupId > junit </ groupId >
                 < artifactId > junit </ artifactId >
                 < version > 4.4 </ version >
                 < scope > test </ scope >
            </ dependency >
            < dependency >
                 < groupId > org.apache.zookeeper </ groupId >
                 < artifactId > zookeeper </ artifactId >
                 < version > 3.4.6 </ version >
            </ dependency >
      </ dependencies >
     
  • 类说明，总共新建6个Java类，其中：
       HdfsDao.java：操作HDFS的工具类，实现本地对HDFS文件的基本操作，常规操作，有兴趣可以参考项目源码；               Purchase.java：基于MapReduce的采购金额的计算：（一个简单的MR任务）
  
package org.bd.ytg.zookeeper;

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.regex.Pattern;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.bd.ytg.hdfs.HdfsDao;


/**
 * 计算2013年1月的采购金额
 * @author gaoyongtao
 *
 * 2017年11月8日
 */
public class Purchase {
	
	public static final String HDFS_HOST = "hdfs://192.168.203.10:9000/";
	
	public static final Pattern DELIMITER = Pattern.compile("[\t,]");
	
	
	public  static class  PurchaseMapper extends MapReduceBase implements Mapper<LongWritable, Text, Text, IntWritable>{
		//一共4列，分别对应 产品ID,产品数量,产品单价,采购日期
		//		1,26,1168,2013-01-08
		//		2,49,779,2013-02-12
		//		3,80,850,2013-02-05
		//		4,69,1585,2013-01-26
		//		5,88,1052,2013-01-13
		
		public static final String MONTH = "2013-01";
		
		// 输出的Key
		static Text oneMonth = new Text(MONTH);
		
		// 输出的value
		IntWritable money = new IntWritable();
		
		@Override
		public void map(LongWritable key, Text value,OutputCollector<Text, IntWritable> outputCollector, Reporter reporter)
				throws IOException {
		// hadoop的输入 这个value是1行数据，是的;每一行数据列之间以'/t'进行分割
			System.out.println("PurchaseMapper excete in map,key=:"+key+",line=:"+value.toString());
			//PurchaseMapper excete in map,key=:0,line=:1,26,1168,2013-01-08
			String[] datas = DELIMITER.split(value.toString());
			if(datas.length>=3 && datas[3].startsWith(MONTH)){
				int sum = 0;
				sum = Integer.parseInt(datas[1]) * Integer.parseInt(datas[2]);
				money.set(sum);
				outputCollector.collect(oneMonth, money);
			}
		}
		
	}
	
	public static class PurchaseReducer extends  MapReduceBase implements Reducer<Text, IntWritable, Text, IntWritable>{

		private IntWritable v = new IntWritable();
		
		Text myKey = new Text();
		
	    private int totalMoney = 0;
	     
	    @Override
	    public void reduce(Text key, Iterator<IntWritable> values,OutputCollector<Text, IntWritable> outputCollector, Reporter reporter)
				throws IOException {
			while(values.hasNext()){
				int money = values.next().get();
				System.out.println("PurchaseReducer excete in reduce,key=:"+key+",values.next().get()=:"+money);
				totalMoney += money;
			}
			//myKey.set(string);
			v.set(totalMoney);
//			outputCollector.collect(key, v);  //如果此处输出带上key，则MR的输出即为2013-01，XXXX
			outputCollector.collect(null, v); // 不带key，则MR输出为XXXX，只有一个金额
			System.out.println("Output:" + key + "," + totalMoney);
		}
	}
	
	 public static void runPurchase(Map<String, String> path) throws IOException, InterruptedException, ClassNotFoundException {
	        JobConf conf = getHadoopConfig();
	        String local_data = path.get("purchase");
	        String input = path.get("input");
	        String output = path.get("output");

	        // 初始化HDFS访问层
	        HdfsDao hdfs = new HdfsDao(HDFS_HOST, conf);
	        hdfs.rmr(input);
//	        hdfs.rmr(output);
	        hdfs.mkdirs(input);
	        hdfs.copyFile(local_data, input);

	    	conf.setOutputKeyClass(Text.class);
			conf.setOutputValueClass(IntWritable.class);

			conf.setMapperClass(PurchaseMapper.class);
			conf.setReducerClass(PurchaseReducer.class);

			conf.setInputFormat(TextInputFormat.class);
			conf.setOutputFormat(TextOutputFormat.class);

			FileInputFormat.setInputPaths(conf, new Path(input));
			FileOutputFormat.setOutputPath(conf, new Path(output));

			JobClient.runJob(conf);
	    }
	 
	 public static JobConf getHadoopConfig() {
			JobConf conf = new JobConf();
			conf.setJobName("purchaseJob");
			conf.addResource("classpath:/hadoop/core-site.xml");
			conf.addResource("classpath:/hadoop/hdfs-site.xml");
			conf.addResource("classpath:/hadoop/mapred-site.xml");
			conf.addResource("classpath:/hadoop/masters");
			conf.addResource("classpath:/hadoop/slaves");
			return conf;
		}
	 
	 public static Map<String,String> pathConfigMap(){
	        Map<String, String> path = new HashMap<String, String>();
	        path.put("purchase", "logfile/biz/purchase.csv");// 本地的数据文件
	        path.put("input", HDFS_HOST + "dataguru/hdfs/purchase/");// HDFS的目录
	        path.put("output", HDFS_HOST + "purchaseresult"); // 输出目录
	        return path;
	    }
	 
	   public static void main(String[] args) throws Exception {
		   
		   runPurchase(pathConfigMap());
	    }

}

       Sell.java：MapReduce的销售金额的计算：
        Other.java ：其他费用的Java App计算；
        ProfitCaculate.java：利润计算的Java App；
        ZookeeperJob.java :ZK任务调度类， 各个业务节点，在完成自身节点创建完成后，判断队列创建是否完成(/queue的子节点个数是否等于3)，如果是，则触发对PROFIT        节点的创建，生成利润节点，进行利润的计算：
      
package org.bd.ytg.zookeeper;

import java.io.IOException;
import java.util.List;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
/**
 * ZooKeeper任务调度类：
 * 各个业务节点，在完成自身节点创建完成后，判断队列创建是否完成(/queue的子节点个数是否等于3)，
 * 如果是，则触发对PROFIT节点的创建，生成利润节点，进行利润的计算
 * @author gaoyongtao
 *
 * 2017年11月8日
 */
public class ZooKeeperJob {
	
    final public static String QUEUE = "/queue";   //父節點
    final public static String PURCHASE = "/queue/purchase";
    final public static String SELL = "/queue/sell";
    final public static String OTHER = "/queue/other";
    
    final public static String PROFIT = "/queue/profit";

    
    // 创建一个与服务器的连接,监控节点创建事件
    public static ZooKeeper connection(String host) throws IOException {
        ZooKeeper zk = new ZooKeeper(host, 60000, new Watcher() {
            // 监控所有被触发的事件
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeCreated && event.getPath().equals(PROFIT)) {
                    System.out.println("Queue has Completed!!!");
                }
            }
        });
        return zk;
    }
    
    // 初始化隊列
    public static void initQueue(ZooKeeper zooKeeper) throws KeeperException, InterruptedException{
    	System.out.println("WATCH => " + PROFIT);
    	
    	// 如果這個節點存在
    	zooKeeper.exists(QUEUE, true);
    	
    	// 節點不存在，則創建該節點
    	if (zooKeeper.exists(QUEUE, false) == null) {
            System.out.println("create " + QUEUE);
            zooKeeper.create(QUEUE, QUEUE.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println(QUEUE + " is exist!");
        }
    }
    
   // 判斷隊列的節點是否全部創建完成
    public static void isCompleted(ZooKeeper zk) throws Exception {
    	// 共三個節點：採購、銷售、其他
        int size = 3;
        List<String> children = zk.getChildren(QUEUE, true);
        int length = children.size();

        System.out.println("Queue Complete:" + length + "/" + size);
        if (length >= size) {
            System.out.println("create " + PROFIT);
            
            String profit = String.valueOf(ProfitCaculate.profit());
            
            System.out.println(profit);
            
            zk.create(PROFIT, profit.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            
            List<String> queueChildren = zk.getChildren(QUEUE, true);
            
            for (String child : queueChildren) {
            	System.out.println("完成利润节点的创建，Queue的子节点有：");
				System.out.print(child+" ");
			}
            
           try {
			   String profitMoney = new String(zk.getData(PROFIT, null, null));
			   
			   System.out.println(profitMoney);
		} catch (Exception e) {
			System.out.println("获取PROFIT值异常");
			e.printStackTrace();
		}
            

         /*   for (String child : children) {// 清空节点,釋放服務器對該業務節點的監控，保留利润节点
            	if(!PROFIT.equals(QUEUE + "/" + child)){
            		zk.delete(QUEUE + "/" + child, -1);
            	}
            }*/
        }
    }
    
    // 如果隊列上不存在採購節點，則執行採購金額計算MR任務，并創建採購節點，完成后判斷隊列節點是否創建完成
    public static void doPurchase(ZooKeeper zk) throws Exception {
        if (zk.exists(PURCHASE, false) == null) {
            
            Purchase.runPurchase(Purchase.pathConfigMap());
            
            System.out.println("create " + PURCHASE);
            zk.create(PURCHASE, PURCHASE.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println(PURCHASE + " is exist!");
        }
        isCompleted(zk);
    }

 // 如果隊列上不存在銷售節點，則執行銷售金額計算MR任務，并創建銷售節點，完成后判斷隊列節點是否創建完成
    public static void doSell(ZooKeeper zk) throws Exception {
        if (zk.exists(SELL, false) == null) {
            
            Sell.runSell(Sell.pathConfigMap());
            
            System.out.println("create " + SELL);
            zk.create(SELL, SELL.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println(SELL + " is exist!");
        }
        isCompleted(zk);
    }

   // 如果隊列上不存在其他費用節點，則執行其他費用金額計算任務，并創建採購節點，完成后判斷隊列節點是否創建完成
    public static void doOther(ZooKeeper zk) throws Exception {
        if (zk.exists(OTHER, false) == null) {
            
            Other.calcOther(Other.file);
            
            System.out.println("create " + OTHER);
            zk.create(OTHER, OTHER.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println(OTHER + " is exist!");
        }
        isCompleted(zk);
    }
    

    public static void doAction(int client) throws Exception {
        String host1 = "192.168.203.10:2181";
        String host2 = "192.168.203.10:2181";
        String host3 = "192.168.203.10:2181";

        ZooKeeper zk = null;
        switch (client) {
        case 1:
            zk = connection(host1);
            initQueue(zk);
            doPurchase(zk);
            break;
        case 2:
            zk = connection(host2);
            initQueue(zk);
            doSell(zk);
            break;
        case 3:
            zk = connection(host3);
            initQueue(zk);
            doOther(zk);
            break;
        }
    }
    
    public static void main(String[] args) throws Exception {
    	    doAction(Integer.parseInt("1"));
            doAction(Integer.parseInt("2"));
            doAction(Integer.parseInt("3"));
            
    }
}


      6.程序运行：
      启动Hadoop集群，启动ZK集群，检查应用进程均正常：（master既作为Hadoop的主节点，也作为Zookeeper的主节点，salve1和slave2作为从节点）
  
         分别进行调试，完成两个MapReduce任务单独运行成功( 确保MR任务无bug，毕竟此处这不是我们的重点 )；
           
          运行过MR任务后，需要对HDFS进行初始化，还原到最初的环境，人生若只如初见：
      
        
       下面，运行 ZookeeperJob.java中的main方法，进行集群协调的验证，运行结果：
        实验数据文件由本地上传至HDFS：
      
           
       采购MapReduce任务金额的计算：
      

       销售MapReduce任务金额的计算：
        
       其他费用为本地Java 应用计算金额：
        

       查看 Zookeeper的queue队列： (此处为查看计算结果，暂未删除ZK节点释放资源)：
      
        查看Zookeeper上的profit节点：
      
       Eclipse输出日志：
       

  7.小结：        
       通过同步的分步式队列自动启动了计算利润的程序，并在日志中打印了2013年1月的利润为-6693765，以此模拟实现这个分布式队列的Demo完成。 当然程序中还有许多不严谨的地方，以待继续优化完善，不知情所起，一往情深。



附：完整项目代码参考：https://gitee.com/tonnygao/JiYuZooKeeperShiXianFenBuShiDuiLieXiTongShiXianMapReduceRenWuJiCheng.git


















秋水长天点点滴滴
关注
大数据介绍 Hadoop 伪分布式 完全分布式 HDFS MapReduce yarn zookeeper
嘭嘭啊啊啊的博客
08-10 999
大数据 数据：字母 数字 声音 影像等都是数据 数据没有任何含义，仅代表一个符号。数据是信息的载体。 信息：数据经过解释加工之后，赋予一定的含义。 信息量：消除人们对不确定因素的大小 大： 1 数据量大 基于非常非常大量的数据，甚至是海量数据才能给我们带来一定的价值。 价值是从这些数据中挖掘出来的。 2.大数据的技术 在海量数据的基础上，必须产生能处理这么大数据量的技术。 大数据： 大数据（big data），是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的数据集合，是需要新处理模式才能具有更强
HDFS、Zookeeper、MapReduce简述
灰哀之雪的博客
09-12 761
一、 简述HDFS的体系结构 HDFS的全称是 Hadoop Distributed System HDFS采用的是 master/slaves 这种主从的结构模型来管理数据。这种结构模型主要由四部分组成，分别是：Client(客户端)、Namenode(元数据节点)、Datanode(数据节点)和SecondaryNamenode。 元数据节点用来管理文件系统的命名空间 其将所有的文件和文件夹的元数据保存在一个文件系统树中。 这些信息也会在硬盘上保存成以下文件：命名空间镜像(namespace im
ZooKeeper实现分布式FIFO队列
02-26
文章介绍了如何整合虚拟化和Hadoop，让Hadoop集群跑在VPS虚拟主机上，通过云向用户提供存储和计算的服务。现在硬件越来越便宜，一台非品牌服务器，2颗24核CPU，配48G内存，2T的硬盘，已经降到2万块人民币以下了。这种配置如果简单地放几个web应用，显然是奢侈的浪费。就算是用来实现单节点的hadoop，对计算资源浪费也是非常高的。对于这么高性能的计算机，如何有效利用计算资源，就成为成本控制的一项重要议题了。通过虚拟化技术，我们可以将一台服务器，拆分成12台VPS，每台2核CPU，4G内存，40G硬盘，并且支持资源重新分配。多么伟大的技术啊！现在我们有了12个节点的hadoop集群，让
基于ZooKeeper的分布式锁和队列
weixin_34342992的博客
10-18 145
在分布式系统中，往往需要一些分布式同步原语来做一些协同工作，上一篇文章介绍了Zookeeper的基本原理，本文介绍下基于Zookeeper的Lock和Queue的实现，主要代码都来自Zookeeper的官方recipe。 锁（Lock） 完全分布式锁是全局同步的，这意味着在任何时刻没有两个客户端会同时认为它们都拥有相同的锁，使用 Zookeeper 可以实现分布式锁，需要首先定义一个锁节点（l...
zookeeper实现分布式队列
mjlfto的博客
01-22 500
zookeeper实现分布式队列 利用zookeeper的有序节点和节点一旦被删除，其他连接就不能重复删除的特性实现一个非常简单的分布式队列，说实话，我觉得用zookeeper实习分布式队列并不合适，而且我这里实现的也是最简单的，效率也不高 实现细节，利用create -s /queue/q_创建有序节点，这样数据就放到队列了，当然这一步是使用zookeeper的客户端Curator实现的，然后取...
Zookeeper实现分布式队列
jockerwu的博客
12-08 2110
常见的消息队列有:RabbitMQ，RocketMQ，Kafka等。Zookeeper作为一个分布式的小文件管理系统，同样能实现简单的队列功能。Zookeeper不适合存储大数据量存储，官方并不推荐作为队列使用，但由于实现简单，集群搭建较为便利，因此在一些吞吐量不高的小型系统中还是比较好用的。 本案例设立一个订单生产者，两个订单消费者，订单生产者将下单信息存入Zookeeper队列，两个消费者监听队列，共同消费订单。以此模拟下单业务，使用队列来提升订单系统的可用性及处理订单的吞吐量。 1.项目依赖 在
基于kafka，zookeeper实现的日志收集平台搭建
qq_57472200的博客
08-14 1842
l项目描述：分别使用3台Linux服务器来作为nginx集群搭建前端web服务，kafka集群和zookeeper集群,2台Linux机器做反向代理集群。
Zookeeper&YARN
leezsj的博客
07-06 353
Zookeeper&YARN Zookeeper的概述 Zookeeper是什么 1. zookeeper是⼀个为分布式应⽤程序提供的⼀个分布式开源协调服务框架。是Google的Chubby的⼀个开源实现，是Hadoop和Hbase的重要组件。主要⽤于解决分布式集群中应⽤系统的⼀致性问题。 2. 提供了基于类似Unix系统的⽬录节点树⽅式的数据存储。 3. 可⽤于维护和监控存储的数据的状态的变化，通过监控这些数据状态的变化，从⽽达到基于数据的集群管理 4. 提供了⼀组原语(机器指令)，提供了
oozie与ZooKeeper的集成与分布式协调
分布式系统由多个独立的计算机节点组成，这些节点之间通过网络进行通信和协作，以实现高性能、高可用性和横向扩展等目标。然而，分布式系统带来了一系列的挑战，包括协调问题、一致性问题和故障容错问题等。 协调是...
ZooKeeper实现分布式队列Queue
Make progress step by step everyday.....
12-06 543
ZooKeeper实现分布式队列Queue 让Hadoop跑在云端系列文章，介绍了如何整合虚拟化和Hadoop，让Hadoop集群跑在VPS虚拟主机上，通过云向用户提供存储和计算的服务。 现在硬件越来越便宜，一台非品牌服务器，2颗24核CPU，配48G内存，2T的硬盘，已经降到2万块人民币以下了。这种配置如果简单地放几个web应用，显然是奢侈的浪费。就算是用来实现单节点的hadoop，对计
zookeeper的学习（一）：实现分布式队列queue
迪迪调调的博客
06-25 1051
算法流程图： 核心方法的简要概述： 1.offer方法 在zookeeper下创建临时顺序节点。 2 poll方法 由于队列的先进先出特性，所以poll方法，就是读取zookeeper队列节点下所有子节点最小number的那个节点，读到数据， 则返回且删除该节点 代码： package com.zk.queue; import java.util.Collecti...
Zookeeper分布式队列的实现
杨春建的博客
03-12 605
原文地址：http://blog.csdn.net/Evankaka/article/details/70806752摘要：本文要通过zookeeper实现一个简单可靠的分布式队列本文源码请在这里下载：https://github.com/yangchunjian/DistributeLearning一、队列Zookeeper可以处理两种类型的队列：（1）同步队列当一个队列的成员都聚齐时，这个队列...
Zookeeper实现分布式队列(非阻塞式)
qq_49150614的博客
05-20 456
分布式环境下，一个类似单进程队列的组件，用来实现跨进程、跨主机、跨网络的数据共享和数据传递，zookeeper可以通过顺序节点实现分布分布式队列.
Hadoop、mapreduce、Zookeeper
youaresobeautiful
07-26 273
谈谈什么是Hadoop? Hadoop是一个开源软件框架，用于存储大量数据，并发计算/查询节点的集群上的数据。 Hadoop包括以下内容： 　　HDFS(Hadoop Distributed File System)：Hadoop分布式文件存储系统。 　　MapReduce：分布式计算框架。它以分布式和并行的方式处理大量的数据。 　　YARN(资源定位器)：用于管理和调度集群资源的框架。 MapReducer核心思想 1）分布式的运算程序往往需要分成至少2个阶段。 2）第一个阶段的MapTask并发实例，完
zookeeper应用之分布式队列
最新发布
sinat_16493273的博客
11-20 905
curator对优先队列(DistributedPriorityQueue)、延迟队列(DistributedDelayQueue)都有对应的实现，有兴趣的自己看吧。然后是消息的consumer，这里肯定是使用的watcher。这里有个问题有没有发现，在初始化queue的时候需要指定consumer，那岂不是只能同一个程序中生产消费，何来的分布式？这样在启动测试程序在，consumer的consumeMessage方法就会收到queue.put的消息。这里设置了数据，然后具体的数据消费在下一步。
zookeeper 实现分布式队列
惜暮
03-19 2278
zookeeper是一种高性能，可扩展的服务。其本身提供了一致性保证，特点如下：（1）顺序一致性：客户端的更新顺序与它们被发送的顺序一致。（2）原子性：更新操作要么成功，要么失败，没有第三种结果。（3）单系统镜像：无论客户端连接到哪一个服务器，他都将看到相同的zookeeper视图。（4）可靠性：一旦一个更新操作被应用，那么在客户端再次更新之前，其值不会再改变。zookeeper实现分布式队列基于
ZooKeeper在分布式环境中的应用实践
分布式计算框架如MapReduce可以利用ZooKeeper进行任务调度，分配和跟踪计算任务。 9. **容错和故障转移** 当节点发生故障时，ZooKeeper可以检测到并触发相应的故障恢复机制。 ZooKeeper凭借其强大的一致性保证和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值