备案控制台
探索云世界
开发者社区 大数据 文章 正文

Storm的wordCounter计数器详解

2014-03-31 1012
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原文：http://www.maoxiangyi.cn/index.php/archives/362 拓扑 点击(此处)折叠或打开 package cn.
原文：http://www.maoxiangyi.cn/index.php/archives/362

拓扑

点击(此处)折叠或打开

  1. package cn.jd.storm;

  3. import backtype.storm.Config;
  4. import backtype.storm.LocalCluster;
  5. import backtype.storm.topology.TopologyBuilder;
  6. import backtype.storm.tuple.Fields;
  7. /**
  8.  * 功能说明：
  9.  * 设计一个topology，来实现对一个句子里面的单词出现的频率进行统计。
  10.  * 整个topology分为三个部分：
  11.  *         WordReader:数据源，负责发送单行文本记录（句子）
  12.  *         WordNormalizer:负责将单行文本记录（句子）切分成单词
  13.  *         WordCounter:负责对单词的频率进行累加
  14.  *
  15.  * @author 毛祥溢
  16.  * Email:frank@maoxiangyi.cn
  17.  * 2013-8-26 下午5:59:06
  18.  */
  19. public class TopologyMain {

  21.     /**
  22.      * @param args 文件路径
  23.      */
  24.     public static void main(String[] args)throws Exception {
  25.         // Storm框架支持多语言，在JAVA环境下创建一个拓扑，需要使用TopologyBuilder进行构建
  26.         TopologyBuilder builder = new TopologyBuilder();
  27.         /* WordReader类，主要是将文本内容读成一行一行的模式
  28.          * 消息源spout是Storm里面一个topology里面的消息生产者。
  29.          * 一般来说消息源会从一个外部源读取数据并且向topology里面发出消息：tuple。
  30.          * Spout可以是可靠的也可以是不可靠的。
  31.          * 如果这个tuple没有被storm成功处理，可靠的消息源spouts可以重新发射一个tuple，但是不可靠的消息源spouts一旦发出一个tuple就不能重发了。
  32.          *
  33.          * 消息源可以发射多条消息流stream。多条消息流可以理解为多中类型的数据。
  34.          * 使用OutputFieldsDeclarer.declareStream来定义多个stream，然后使用SpoutOutputCollector来发射指定的stream。
  35.          *
  36.          * Spout类里面最重要的方法是nextTuple。要么发射一个新的tuple到topology里面或者简单的返回如果已经没有新的tuple。
  37.          * 要注意的是nextTuple方法不能阻塞，因为storm在同一个线程上面调用所有消息源spout的方法。
  38.          *
  39.          * 另外两个比较重要的spout方法是ack和fail。storm在检测到一个tuple被整个topology成功处理的时候调用ack，否则调用fail。storm只对可靠的spout调用ack和fail。
  40.          */
  41.         builder.setSpout("word-reader",new WordReader());
  42.         /* WordNormalizer类，主要是将一行一行的文本内容切割成单词
  43.          *
  44.          * 所有的消息处理逻辑被封装在bolts里面。Bolts可以做很多事情：过滤，聚合，查询数据库等等。
  45.          * Bolts可以简单的做消息流的传递。复杂的消息流处理往往需要很多步骤，从而也就需要经过很多bolts。
  46.          * 比如算出一堆图片里面被转发最多的图片就至少需要两步：
  47.          *     第一步算出每个图片的转发数量。
  48.          *     第二步找出转发最多的前10个图片。（如果要把这个过程做得更具有扩展性那么可能需要更多的步骤）。
  49.          *
  50.          * Bolts可以发射多条消息流， 使用OutputFieldsDeclarer.declareStream定义stream，使用OutputCollector.emit来选择要发射的stream。
  51.          * Bolts的主要方法是execute, 它以一个tuple作为输入，bolts使用OutputCollector来发射tuple。
  52.          * bolts必须要为它处理的每一个tuple调用OutputCollector的ack方法，以通知Storm这个tuple被处理完成了，从而通知这个tuple的发射者spouts。
  53.          * 一般的流程是： bolts处理一个输入tuple, 发射0个或者多个tuple, 然后调用ack通知storm自己已经处理过这个tuple了。storm提供了一个IBasicBolt会自动调用ack。
  54.          *
  55.          *
  56.          */
  57.         builder.setBolt("word-normalizer", new WordNormalizer()).shuffleGrouping("word-reader");
  58.         /*
  59.          * 上面的代码和下面的代码中都设定了数据分配的策略stream grouping
  60.          * 定义一个topology的其中一步是定义每个bolt接收什么样的流作为输入。stream grouping就是用来定义一个stream应该如果分配数据给bolts上面的多个tasks。
  61.          * Storm里面有7种类型的stream grouping
  62.          *         Shuffle Grouping: 随机分组， 随机派发stream里面的tuple，保证每个bolt接收到的tuple数目大致相同。
  63.          *         Fields Grouping：按字段分组， 比如按userid来分组， 具有同样userid的tuple会被分到相同的Bolts里的一个task，
  64.          *             而不同的userid则会被分配到不同的bolts里的task。
  65.          *         All Grouping：广播发送，对于每一个tuple，所有的bolts都会收到。
  66.          *         Global Grouping：全局分组， 这个tuple被分配到storm中的一个bolt的其中一个task。再具体一点就是分配给id值最低的那个task。
  67.          *         Non Grouping：不分组，这stream grouping个分组的意思是说stream不关心到底谁会收到它的tuple。
  68.          *             目前这种分组和Shuffle grouping是一样的效果， 有一点不同的是storm会把这个bolt放到这个bolt的订阅者同一个线程里面去执行。
  69.          *         Direct Grouping： 直接分组， 这是一种比较特别的分组方法，用这种分组意味着消息的发送者指定由消息接收者的哪个task处理这个消息。
  70.          *             只有被声明为Direct Stream的消息流可以声明这种分组方法。而且这种消息tuple必须使用emitDirect方法来发射。
  71.          *             消息处理者可以通过TopologyContext来获取处理它的消息的task的id （OutputCollector.emit方法也会返回task的id）。
  72.          *         Local or shuffle grouping：如果目标bolt有一个或者多个task在同一个工作进程中，tuple将会被随机发生给这些tasks。
  73.          *             否则，和普通的Shuffle Grouping行为一致。
  74.          *
  75.          */
  76.         builder.setBolt("word-counter", new WordCounter(),1).fieldsGrouping("word-normalizer", new Fields("word"));
  77.  
  78.         /*
  79.          * storm的运行有两种模式: 本地模式和分布式模式.
  80.          * 1) 本地模式：
  81.          *         storm用一个进程里面的线程来模拟所有的spout和bolt. 本地模式对开发和测试来说比较有用。
  82.          *         你运行storm-starter里面的topology的时候它们就是以本地模式运行的， 你可以看到topology里面的每一个组件在发射什么消息。
  83.          * 2) 分布式模式：
  84.          *         storm由一堆机器组成。当你提交topology给master的时候， 你同时也把topology的代码提交了。
  85.          *         master负责分发你的代码并且负责给你的topolgoy分配工作进程。如果一个工作进程挂掉了， master节点会把认为重新分配到其它节点。
  86.          * 下面是以本地模式运行的代码:
  87.          *
  88.          * Conf对象可以配置很多东西， 下面两个是最常见的：
  89.          *        TOPOLOGY_WORKERS(setNumWorkers) 定义你希望集群分配多少个工作进程给你来执行这个topology.
  90.          *            topology里面的每个组件会被需要线程来执行。每个组件到底用多少个线程是通过setBolt和setSpout来指定的。
  91.          *            这些线程都运行在工作进程里面. 每一个工作进程包含一些节点的一些工作线程。
  92.          *            比如， 如果你指定300个线程，60个进程， 那么每个工作进程里面要执行6个线程， 而这6个线程可能属于不同的组件(Spout, Bolt)。
  93.          *            你可以通过调整每个组件的并行度以及这些线程所在的进程数量来调整topology的性能。
  94.          *        TOPOLOGY_DEBUG(setDebug), 当它被设置成true的话， storm会记录下每个组件所发射的每条消息。
  95.          *            这在本地环境调试topology很有用， 但是在线上这么做的话会影响性能的。
  96.          */
  97.         Config conf = new Config();
  98.         conf.setDebug(true);
  99.         conf.setNumWorkers(2);
  100.         conf.put("wordsFile","/root/workspace1/com.jd.storm.demo/src/main/resources/words.txt");
  101.         conf.setDebug(true);
  102.         conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);
  103.         /*
  104.          * 定义一个LocalCluster对象来定义一个进程内的集群。提交topology给这个虚拟的集群和提交topology给分布式集群是一样的。
  105.          * 通过调用submitTopology方法来提交topology， 它接受三个参数：要运行的topology的名字，一个配置对象以及要运行的topology本身。
  106.          * topology的名字是用来唯一区别一个topology的，这样你然后可以用这个名字来杀死这个topology的。前面已经说过了， 你必须显式的杀掉一个topology， 否则它会一直运行。
  107.          */
  108.         LocalCluster cluster = new LocalCluster();
  109.         cluster.submitTopology("wordCounterTopology", conf, builder.createTopology());
  110.         Thread.sleep(1000);
  111.         cluster.killTopology("wordCounterTopology");
  112.         cluster.shutdown();
  113.     }

  115. }

读句子

点击(此处)折叠或打开

  1. package cn.jd.storm;

  3. import java.io.BufferedReader;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileReader;
  6. import java.util.Map;

  8. import backtype.storm.spout.SpoutOutputCollector;
  9. import backtype.storm.task.TopologyContext;
  10. import backtype.storm.topology.OutputFieldsDeclarer;
  11. import backtype.storm.topology.base.BaseRichSpout;
  12. import backtype.storm.tuple.Fields;
  13. import backtype.storm.tuple.Values;
  14. /**
  15.  *
  16.  * 功能说明：
  17.  *         主要是将文件内容读出来，一行一行
  18.  *
  19.  *     Spout类里面最重要的方法是nextTuple。
  20.  *     要么发射一个新的tuple到topology里面或者简单的返回如果已经没有新的tuple。
  21.  *     要注意的是nextTuple方法不能阻塞，因为storm在同一个线程上面调用所有消息源spout的方法。
  22.  *     另外两个比较重要的spout方法是ack和fail。
  23.  *     storm在检测到一个tuple被整个topology成功处理的时候调用ack，否则调用fail。
  24.  * storm只对可靠的spout调用ack和fail。
  25.  *
  26.  * @author 毛祥溢
  27.  * Email:frank@maoxiangyi.cn
  28.  * 2013-8-26 下午6:05:46
  29.  */
  30. public class WordReader extends BaseRichSpout {

  32.     private SpoutOutputCollector collector;
  33.     private FileReader fileReader;
  34.     private String filePath;
  35.     private boolean completed = false;
  36.     //storm在检测到一个tuple被整个topology成功处理的时候调用ack，否则调用fail。
  37.     public void ack(Object msgId) {
  38.         System.out.println("OK:"+msgId);
  39.     }
  40.     public void close() {}
  41.     //storm在检测到一个tuple被整个topology成功处理的时候调用ack，否则调用fail。
  42.     public void fail(Object msgId) {
  43.         System.out.println("FAIL:"+msgId);
  44.     }
  45.  
  46.   /*
  47.    * 在SpoutTracker类中被调用，每调用一次就可以向storm集群中发射一条数据（一个tuple元组），该方法会被不停的调用
  48.    */
  49.     public void nextTuple() {
  50.         if(completed){
  51.             try {
  52.                 Thread.sleep(1000);
  53.             } catch (InterruptedException e) {
  54.             }
  55.             return;
  56.         }
  57.         String str;
  58.         BufferedReader reader =new BufferedReader(fileReader);
  59.         try{
  60.             while((str = reader.readLine()) != null){
  61.                 System.out.println("WordReader类 读取到一行数据："+ str);
  62.                 this.collector.emit(new Values(str),str);
  63.                 System.out.println("WordReader类 发射了一条数据："+ str);
  64.             }
  65.         }catch(Exception e){
  66.             throw new RuntimeException("Error reading tuple",e);
  67.         }finally{
  68.             completed = true;
  69.         }
  70.     }
  71.  
  72.     public void open(Map conf, TopologyContext context,SpoutOutputCollector collector) {
  73.         try {
  74.             this.fileReader = new FileReader(conf.get("wordsFile").toString());
  75.         } catch (FileNotFoundException e) {
  76.             throw new RuntimeException("Error reading file ["+conf.get("wordFile")+"]");
  77.         }
  78.         this.filePath    = conf.get("wordsFile").toString();
  79.         this.collector = collector;
  80.     }
  81.     /**
  82.      * 定义字段id，该id在简单模式下没有用处，但在按照字段分组的模式下有很大的用处。
  83.      * 该declarer变量有很大作用，我们还可以调用declarer.declareStream();来定义stramId，该id可以用来定义更加复杂的流拓扑结构
  84.      */
  85.     public void declareOutputFields(OutputFieldsDeclarer declarer) {
  86.         declarer.declare(new Fields("line"));
  87.     }
  88. }

将句子切割成单词

点击(此处)折叠或打开

  1. package cn.jd.storm;

  3. import backtype.storm.topology.BasicOutputCollector;
  4. import backtype.storm.topology.OutputFieldsDeclarer;
  5. import backtype.storm.topology.base.BaseBasicBolt;
  6. import backtype.storm.tuple.Fields;
  7. import backtype.storm.tuple.Tuple;
  8. import backtype.storm.tuple.Values;
  9. /**
  10.  *
  11.  * 功能说明：
  12.  *     将一行文本切割成单词，并封装collector中发射出去
  13.  *
  14.  * @author 毛祥溢
  15.  * Email:frank@maoxiangyi.cn
  16.  * 2013-8-26 下午6:05:59
  17.  */
  18. public class WordNormalizer extends BaseBasicBolt {

  20.     public void cleanup() {
  21.         System.out.println("将一行文本切割成单词，并封装collector中发射出去 ---完毕！");
  22.     }
  23.     
  24.     /**
  25.      * 接受的参数是WordReader发出的句子，即input的内容是句子
  26.      * execute方法，将句子切割形成的单词发出
  27.      */
  28.     public void execute(Tuple input, BasicOutputCollector collector) {
  29.         String sentence = input.getString(0);
  30.         String[] words = sentence.split(" ");
  31.         System.out.println("WordNormalizer类 收到一条数据，这条数据是： "+ sentence);
  32.         for(String word : words){
  33.             word = word.trim();
  34.             if(!word.isEmpty()){
  35.                 word = word.toLowerCase();
  36.                 System.out.println("WordNormalizer类 收到一条数据，这条数据是： "+ sentence+"数据正在被切割，切割出来的单词是 "+ word);
  37.                 collector.emit(new Values(word));
  38.             }
  39.         }
  40.     }
  41.  
  42.     /**
  43.     * 定义字段id，该id在简单模式下没有用处，但在按照字段分组的模式下有很大的用处。
  44.     * 该declarer变量有很大作用，我们还可以调用declarer.declareStream();来定义stramId，该id可以用来定义更加复杂的流拓扑结构
  45.     */
  46.     public void declareOutputFields(OutputFieldsDeclarer declarer) {
  47.         declarer.declare(new Fields("word"));
  48.     }
  49. }

计数器WordCounter

点击(此处)折叠或打开

  1. package cn.jd.storm;

  3. import java.util.HashMap;
  4. import java.util.Map;

  6. import backtype.storm.task.TopologyContext;
  7. import backtype.storm.topology.BasicOutputCollector;
  8. import backtype.storm.topology.OutputFieldsDeclarer;
  9. import backtype.storm.topology.base.BaseBasicBolt;
  10. import backtype.storm.tuple.Tuple;
  11. /**
  12.  *
  13.  * 功能说明：
  14.  *     实现计数器的功能，第一次将collector中的元素存放在成员变量counters（Map）中.
  15.  *     如果counters（Map）中已经存在该元素，getValule并对Value进行累加操作。
  16.  *
  17.  * @author 毛祥溢
  18.  * Email:frank@maoxiangyi.cn
  19.  * 2013-8-26 下午6:06:07
  20.  */
  21. public class WordCounter extends BaseBasicBolt {

  23.     private static final long serialVersionUID = 5678586644899822142L;
  24.     Integer id;
  25.     String name;
  26.      //定义Map封装最后的结果
  27.     MapString, Integer> counters;
  28.  
  29.     /**
  30.      * 在spout结束时被调用，将最后的结果显示出来
  31.      *
  32.      * 結果:
  33.      * -- Word Counter [word-counter-2] --
  34.      * really: 1
  35.      * but: 1
  36.      * application: 1
  37.      * is: 2
  38.      * great: 2
  39.      */
  40.     @Override
  41.     public void cleanup() {
  42.         System.out.println("-- Word Counter ["+name+"-"+id+"] --");
  43.         for(Map.EntryString, Integer> entry : counters.entrySet()){
  44.             System.out.println(entry.getKey()+": "+entry.getValue());
  45.         }
  46.         System.out.println("实现计数器的功能 --完畢！");
  47.     }
  48.  
  49.     /**
  50.      * 初始化操作
  51.      */
  52.     @Override
  53.     public void prepare(Map stormConf, TopologyContext context) {
  54.         this.counters = new HashMapString, Integer>();
  55.         this.name = context.getThisComponentId();
  56.         this.id = context.getThisTaskId();
  57.     }
  58.  
  59.     public void declareOutputFields(OutputFieldsDeclarer declarer) {}
  60.  
  61.     /**
  62.      * 实现计数器的功能，第一次将collector中的元素存放在成员变量counters（Map）中.
  63.      * 如果counters（Map）中已经存在该元素，getValule并对Value进行累加操作。
  64.      */
  65.     public void execute(Tuple input, BasicOutputCollector collector) {
  66.         String str = input.getString(0);
  67.         System.out.println("WordCounter 计数器收到单词 "+ str);
  68.         if(!counters.containsKey(str)){
  69.             counters.put(str, 1);
  70.         }else{
  71.             Integer c = counters.get(str) + 1;
  72.             counters.put(str, c);
  73.         }
  74.     }
  75. }

数据格式
storm ni great he he xi wang
test haha heihei very
are mao xiang yi jd

运行日志

WordReader类 发射了一条数据：storm ni great he he xi wang
WordReader类 发射了一条数据：test haha heihei very

WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 storm
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 ni
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 great
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 he
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 he
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 xi
WordNormalizer类 收到一条数据，这条数据是：    storm ni great he he xi wang数据正在被切割，切割出来的单词是 wang
WordCounter 计数器收到单词 storm
WordCounter 计数器收到单词 ni
WordCounter 计数器收到单词 great
WordCounter 计数器收到单词 he
WordCounter 计数器收到单词 he
WordCounter 计数器收到单词 xi
WordCounter 计数器收到单词 wang


WordNormalizer类 收到一条数据，这条数据是：    test haha heihei very
WordNormalizer类 收到一条数据，这条数据是：    test haha heihei very 数据正在被切割，切割出来的单词是 test
WordNormalizer类 收到一条数据，这条数据是：    test haha heihei very 数据正在被切割，切割出来的单词是 haha
WordNormalizer类 收到一条数据，这条数据是：    test haha heihei very 数据正在被切割，切割出来的单词是 heihei
WordNormalizer类 收到一条数据，这条数据是：    test haha heihei very 数据正在被切割，切割出来的单词是 very
WordCounter 计数器收到单词 test
WordCounter 计数器收到单词 haha
WordCounter 计数器收到单词 heihei
WordCounter 计数器收到单词 very


WordReader类 发射了一条数据：are mao xiang yi jd
WordNormalizer类 收到一条数据，这条数据是：    are mao xiang yi jd
WordNormalizer类 收到一条数据，这条数据是：    are mao xiang yi jd 数据正在被切割，切割出来的单词是 are
WordNormalizer类 收到一条数据，这条数据是：    are mao xiang yi jd 数据正在被切割，切割出来的单词是 mao
WordNormalizer类 收到一条数据，这条数据是：    are mao xiang yi jd 数据正在被切割，切割出来的单词是 xiang
WordNormalizer类 收到一条数据，这条数据是：    are mao xiang yi jd 数据正在被切割，切割出来的单词是 yi
WordNormalizer类 收到一条数据，这条数据是：    are mao xiang yi jd 数据正在被切割，切割出来的单词是 jd
WordCounter 计数器收到单词 are
WordCounter 计数器收到单词 mao
WordCounter 计数器收到单词 xiang
WordCounter 计数器收到单词 yi
WordCounter 计数器收到单词 jd

-- Word Counter [word-counter-2] --
xi: 1
test: 1
heihei: 1
haha: 1
he: 2
storm: 1
wang: 1
jd: 1
xiang: 1
great: 1
are: 1
ni: 1
yi: 1
very: 1
mao: 1
实现计数器的功能 --完畢！
将一行文本切割成单词，并封装collector中发射出去 ---完毕！
文章标签：
容器服务Kubernetes版
流计算
Java
自然语言处理
数据格式
数据库
相关实践学习
容器服务Serverless版ACK Serverless 快速入门：在线魔方应用部署和监控
通过本实验，您将了解到容器服务Serverless版ACK Serverless 的基本产品能力，即可以实现快速部署一个在线魔方应用，并借助阿里云容器服务成熟的产品生态，实现在线应用的企业级监控，提升应用稳定性。
云原生实践公开课
课程大纲 开篇：如何学习并实践云原生技术 基础篇： 5 步上手 Kubernetes 进阶篇：生产环境下的 K8s 实践 相关的阿里云产品：容器服务 ACK 容器服务 Kubernetes 版（简称 ACK）提供高性能可伸缩的容器应用管理能力，支持企业级容器化应用的全生命周期管理。整合阿里云虚拟化、存储、网络和安全能力，打造云端最佳容器化应用运行环境。 了解产品详情: https://www.aliyun.com/product/kubernetes
一见蓝天
目录
相关文章
阿甘兄
|
5月前
|
Java 流计算
119 Storm的并发机制
119 Storm的并发机制
阿甘兄
22 0
cuicuicuic
|
2月前
|
SQL 分布式数据库 Apache
Flink问题之实现state定时输出如何解决
Apache Flink是由Apache软件基金会开发的开源流处理框架，其核心是用Java和Scala编写的分布式流数据流引擎。本合集提供有关Apache Flink相关技术、使用技巧和最佳实践的资源。
cuicuicuic
29 0
Maynor
|
4月前
|
存储 分布式计算 算法
MapReduce计数器,Tash的运行机制,shuffle过程,压缩算法
MapReduce计数器,Tash的运行机制,shuffle过程,压缩算法
Maynor
21 0
豆约翰
|
11月前
|
分布式计算 Hadoop 流计算
Storm集群部署与单词计数程序
Storm集群部署与单词计数程序
豆约翰
55 0
永恒云
|
分布式计算 算法 Spark
Spark的共享变量（广播变量和累加器）底层实现
Spark的共享变量（广播变量和累加器）底层实现
永恒云
204 0
Spark的共享变量（广播变量和累加器）底层实现
技术小哥哥
|
分布式计算 Java Hadoop
Storm编程入门API系列之Storm的Topology多个Workers数目控制实现
技术小哥哥
1318 0
技术小哥哥
|
缓存 分布式计算 Hadoop
Spark RDD概念学习系列之rdd持久化、广播、累加器（十八）
技术小哥哥
1953 0
技术小哥哥
|
Web App开发 分布式计算 大数据
Hadoop MapReduce概念学习系列之map并发任务数和reduce并发任务数的原理和代码实现（十八）
技术小哥哥
2003 0
刘洋intsmaze
|
消息中间件 NoSQL Redis
Storm同步调用之DRPC模型探讨
　　摘要:Storm的编程模型是一个有向无环图，决定了storm的spout接收到外部系统的请求后，spout并不能得到bolt的处理结果并将结果返回给外部请求。所以也就决定了storm无法提供对外部系统的同步调用功能。
刘洋intsmaze
1444 0
涂作权
|
分布式计算 资源调度 Hadoop
Mapreduce和Yarn概念，参数优化，作用，原理，MapReduce计数器 Counter,MapReduce 多job串联之ControlledJob(来自学习资料)
3.3. MapReduce与YARN 3.3.1 YARN概述 Yarn是一个资源调度平台，负责为运算程序提供服务器运算资源，相当于一个分布式的操作系统平台，而mapreduce等运算程序则相当于运行于操作系统之上的应用程序 3.3.2 YARN的重要概念 1、  yarn并不清楚用户提交的程序的运行机制 2、  yarn只提供运算资源的调度（用户程序向yarn申请资源，yarn就负责
涂作权
2051 0

热门文章

最新文章

  • 1
    Mac安装并使用telnet命令操作
  • 2
    OSS回源的几种方式和应用场景
  • 3
    [剑指offer] 孩子们的游戏(圆圈中最后剩下的数)
  • 4
    网络安全系列之二十二 Windows用户账号加固
  • 5
    我理解的一个程序员如何学习前端开发
  • 6
    《社交网站界面设计（原书第2版）》——1.9　为设备之间的空间进行设计
  • 7
    《Microduino实战》——1.2　为什么要开源
  • 8
    .Net函数Math.Round你会用吗？
  • 9
    麻省理工大学新发明：暗黑WiFi透视技术
  • 10
    2014秋C++第19周 补充代码 哈希法的存储与查找
  • 1
    R语言关联规则模型(Apriori算法)挖掘杂货店的交易数据与交互可视化
    25
  • 2
    R语言近似贝叶斯计算MCMC（ABC-MCMC）轨迹图和边缘图可视化
    21
  • 3
    r语言中对LASSO回归，Ridge岭回归和弹性网络Elastic Net模型实现-4
    29
  • 4
    Sentieon | 每周文献-Multi-omics-第四十一期
    25
  • 5
    数据分享|R语言广义线性模型GLM：线性最小二乘、对数变换、泊松、二项式逻辑回归分析冰淇淋销售时间序列数据和模拟-2
    15
  • 6
    数据分享|R语言广义线性模型GLM：线性最小二乘、对数变换、泊松、二项式逻辑回归分析冰淇淋销售时间序列数据和模拟-1
    22
  • 7
    基于RT-Thread摄像头车牌图像采集系统
    21
  • 8
    R语言极值理论：希尔HILL统计量尾部指数参数估计可视化
    15
  • 9
    【视频】R语言中的分布滞后非线性模型（DLNM）与发病率，死亡率和空气污染示例
    18
  • 10
    sql语句创建数据库
    17

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）