storm平台中啥是一系列

Posted 2023-04-28

storm平台中什么是一系列
接触大数据有一段时间了，大部分使用hadoop比较多，但是hadoop主要的使用场景在于离线系统。

现实生活中，一些场景是不允许你有那么长时间的延迟时间，都需要实时数据展示的，显而易见，hadoop是无法满足这种场景下的要求的。

Storm 是Twitter的一个开源框架。Storm一个分布式的、容错的实时计算系统，它被托管在GitHub上，遵循 Eclipse Public License 1.0。Storm是由BackType开发的实时处理系统，BackType现在已在Twitter麾下。GitHub上的最新版本是Storm 0.9.0.1，基本是用Clojure写的。

Twitter Storm集群表面上类似于Hadoop集群，Hadoop上运行的是MapReduce Jobs，而Storm运行topologies；但是其本身有很大的区别，最主要的区别在于，Hadoop MapReduce Job运行最终会完结，而Storm topologies处理数据进程理论上是永久存活的，除非你将其Kill掉。

Storm集群中包含两类节点：主控节点（Master Node）和工作节点（Work Node）。其分别对应的角色如下：
1. 主控节点（Master Node）上运行一个被称为Nimbus的后台程序，它负责在Storm集群内分发代码，分配任务给工作机器，并且负责监控集群运行状态。Nimbus的作用类似于Hadoop中JobTracker的角色。
2. 每个工作节点（Work Node）上运行一个被称为Supervisor的后台程序。Supervisor负责监听从Nimbus分配给它执行的任务，据此启动或停止执行任务的工作进程。每一个工作进程执行一个Topology的子集；一个运行中的Topology由分布在不同工作节点上的多个工作进程组成。

Nimbus和Supervisor节点之间所有的协调工作是通过Zookeeper集群来实现的。此外，Nimbus和Supervisor进程都是快速失败（fail-fast)和无状态（stateless）的；Storm集群所有的状态要么在Zookeeper集群中，要么存储在本地磁盘上。这意味着你可以用kill -9来杀死Nimbus和Supervisor进程，它们在重启后可以继续工作。这个设计使得Storm集群拥有不可思议的稳定性。

在Storm集群上要实现实时计算，需要创建Topologies。一个Topology是一个计算的曲线图。Topology中的每个节点包含处理逻辑，并且节点之间的链路表示数据如何应围绕节点之间传递。

运行一个Topology比较简单，首先，你打包所有的代码和依赖关系的包打成一个jar包。然后，您运行如下命令：

storm jar all-my-code.jar backtype.storm.MyTopology arg1 arg2
这里运行一个包含arg1和arg2两个参数的backtype.storm.MyTopology类。main方法定义Topology以及提交到 Nimbus，storm jar部分连接 Nimbus以及上传jar包到集群。

由于Topology的定义是Thirf结构，并且Nimbus是一个Thirf 服务，所以你可以使用任何语言创建以及提交Topology。

Storm是一个实时流处理框架，那么它的抽象核心当然就是流。 Storm也可被用于“连续计算”（continuous computation），对数据流做连续查询，在计算时就将结果以流的形式输出给用户。它还可被用于“分布式RPC”，以并行的方式运行昂贵的运算。 Storm的主工程师Nathan Marz表示：

Storm可以方便地在一个计算机集群中编写与扩展复杂的实时计算，Storm之于实时处理，就好比 Hadoop之于批处理。Storm保证每个消息都会得到处理，而且它很快——在一个小集群中，每秒可以处理数以百万计的消息。更棒的是你可以使用任意编程语言来做开发。
Storm的主要特点如下：

简单的编程模型。类似于Mapreduce降低了并行批处理复杂性，Storm降低了进行实时处理的复杂性。
可以使用各种编程语言。你可以在Storm之上使用各种编程语言。默认支持Clojure、Java、Ruby和Python。要增加对其他语言的支持，只需实现一个简单的Storm通信协议即可。
容错性。Storm会管理工作进程和节点的故障。
水平扩展。计算是在多个线程、进程和服务器之间并行进行的。
可靠的消息处理。Storm保证每个消息至少能得到一次完整处理。任务失败时，它会负责从消息源重试消息。
快速。系统的设计保证了消息能得到快速的处理，使用ZeroMQ作为其用底层消息队列。
本地模式。Storm有一个“本地模式”，可以在处理过程中完全模拟Storm集群。这让你可以快速进行开发和单元测试。

Storm的术语包括Stream、Spout、Bolt、Task、Worker、Stream Grouping和Topology。Stream是被处理的数据。Sprout是数据源。Bolt处理数据。Task是运行于Spout或Bolt中的 线程。Worker是运行这些线程的进程。Stream Grouping规定了Bolt接收什么东西作为输入数据。数据可以随机分配（术语为Shuffle），或者根据字段值分配（术语为Fields），或者 广播（术语为All），或者总是发给一个Task（术语为Global），也可以不关心该数据（术语为None），或者由自定义逻辑来决定（术语为 Direct）。Topology是由Stream Grouping连接起来的Spout和Bolt节点网络。在Storm 参考技术A storm平台中什么是一系列
流数据分析平台Storm简介 - Data+Science+Insight的博客 - CSDN博客 - stor...

2021年5月11日Storm是一个分布式的、容错的实时流计算系统,可以方便地在一个计算机集群中编写与扩展复杂的...
CSDN编程社区

Storm概念与架构 - 枫叶飘飘的技术博客 - 51CTO博客

1. Tuple:由一组可序列化的元素构成,每个元素可以是任意类型,包括Java原生类型、String、byte[]、自定义类型(必须是可序列化的)等。
2. Stream:无限的Tuple序列形成一个Stream。每个Stream由一个唯一ID、一个对Tuple中元素命名的Schema以及无限Tuple构成。
3. Topology:Storm中的用户应用程序被称为“Topology”,这类似于MapReduce中的“Job”。它是由一系列Spout和Blot构成的DAG,其中每个点表示一个Spout或Blot,
51CTO博客程序员运维工程师博客

Storm 系列(二)实时平台介绍 - 走看看
1. 日志的传输和收集,主要依赖 Blackhole 和 Puma 来完成。 Blackhole 是一个大众评自己开发的类似于 Kafka 的分布式消息系统,收集了除 mysql 日志
2. Storm 是实时平台的核心组成部分,目前在 Storm 上运行了几十个业务 Topology,日处理数据量在百亿级,峰值的数据 TPS 在 10 万左右
3. Topology 中 Bolt 计算的结果数据和中间交换数据根据业务需求存放在 参考技术B Storm 是一个开源的分布式实时计算框架，可以以简单、可靠的方式进行大数据流的处理。通常用于实时分析，在线机器学习、持续计算、分布式 RPC、ETL 等场景。Storm 具有以下特点：

支持水平横向扩展；
具有高容错性，通过 ACK 机制每个消息都不丢失；
处理速度非常快，每个节点每秒能处理超过一百万个 tuples ；
易于设置和操作，并可以与任何编程语言一起使用；
支持本地模式运行，对于开发人员来说非常友好；
支持图形化管理界面。

Java中啥是可调用的？

【中文标题】Java中啥是可调用的？

【英文标题】：What is callable in Java?Java中什么是可调用的？

【发布时间】：2014-09-16 23:14:20

【问题描述】：

标题几乎概括了它。

我想知道 callable 的概念和思想。我已经阅读了question here 关于可调用和可运行之间的区别。但是没有人显示代码并详细说明什么是可调用对象。我不想知道它们之间的区别。我想知道，

什么是可调用对象？

何时使用它们以及如何使用它们。

当他们为 安卓。

【参考方案1】：

你可以查看这个example:

在此示例中，可调用任务在一秒后返回执行任务的线程的名称。我们正在使用 Executor 框架并行执行 100 个任务，并使用 Future 来获取提交任务的结果。

package com.journaldev.threads;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<String> 

    @Override
    public String call() throws Exception 
        Thread.sleep(1000);
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
    

    public static void main(String args[])
        //Get ExecutorService from Executors utility class, thread pool size is 10
        ExecutorService executor = Executors.newFixedThreadPool(10);
        //create a list to hold the Future object associated with Callable
        List<Future<String>> list = new ArrayList<Future<String>>();
        //Create MyCallable instance
        Callable<String> callable = new MyCallable();
        for(int i=0; i< 100; i++)
            //submit Callable tasks to be executed by thread pool
            Future<String> future = executor.submit(callable);
            //add Future to the list, we can get return value using Future
            list.add(future);
        
        for(Future<String> fut : list)
            try 
                //print the return value of Future, notice the output delay in console
                // because Future.get() waits for task to get completed
                System.out.println(new Date()+ "::"+fut.get());
             catch (InterruptedException | ExecutionException e) 
                e.printStackTrace();
            
        
        //shut down the executor service now
        executor.shutdown();
    

您也可以查看Using Callable to Return Results From Runnables

【讨论】：

当它们在 Android 上发挥作用时

【参考方案2】：

Callable 类似于 Runnable 但它返回一个结果并可能抛出异常。 当您希望异步任务返回结果时使用它们。

异步计算的返回结果用Future表示。

您可以查看这个使用FutureTask 实现的简单示例（它实现了RunnableFuture 和Future）

public static void main(String[] args) 

    // providing an anonymous callable to FutureTask
    RunnableFuture<String> future = new FutureTask<String>(
            new Callable<String>() 
                @Override
                public String call() throws InterruptedException 
                    System.out.println("sleeping");
                    Thread.sleep(2000);
                    System.out.println("returning");
                    return "hello-world";
                

            );

    Thread t = new Thread(future);
    t.start();

    try 
        // the get Waits if necessary for the computation to complete
        System.out.println(future.get());
     catch (InterruptedException | ExecutionException e) 
        e.printStackTrace();
    

【讨论】：

在运行未来任务的同一线程中等待有什么意义？

get 调用等待直到结果可用或被中断、取消或发生某些计算异常。请注意，在调用 get 时（在 main 中），处理仍在发生/或已经完成（在线程“t”中）。

@Jimmy Lunceford，您可以与其他线程共享未来的 ref 并调用 get 到您那里，但这里的重点是演示它的作用。即使在这里，未来的任务也会在线程“t”而不是“main”中执行