精华内容
参与话题
问答
  • [Spark]Spark RDD 指南四 RDD操作

    千次阅读 2017-06-13 21:14:25
    Spark2.3.0版本: Spark2.3.0 RDD操作RDD支持两种类型的操作:转移(transformations):从现有数据集创建一个新数据集 动作(actions):在数据集上进行计算后将值返回给驱动程序例如,map是一个转移操作,传递给每个数据...

    Spark2.3.0版本Spark2.3.0 RDD操作

    RDD支持两种类型的操作:

    转移(transformations):从现有数据集创建一个新数据集
    动作(actions):在数据集上进行计算后将值返回给驱动程序

    例如,map是一个转移操作,传递给每个数据集元素一个函数并返回一个新RDD表示返回结果。 另一方面,reduce是一个动作操作,使用一些函数聚合RDD的所有元素并将最终结果返回给驱动程序(尽管还有一个并行的reduceByKey返回分布式数据集)。

    在 Spark 中,所有的转换操作(transformations)都是惰性(lazy)的,它们不会马上计算它们的结果。相反的,它们仅仅记录转换操作是应用到哪些基础数据集(例如一个文件)上的(remember the transformations applied to some base dataset )。只有当动作(action)操作 需要返回一个结果给驱动程序的时候, 转换操作才开始计算。 这个设计能够让 Spark 运行得更加高效。例如,我们可以知道:通过 map 创建的新数据集将在 reduce 中使用,并且仅仅返回 reduce 的结果给驱动程序,而不是将整个大的映射过的数据集返回。

    1. 基础

    为了说明RDD基础知识,请考虑以下简单程序:

    JavaRDD<String> lines = sc.textFile("data.txt");
    JavaRDD<Integer> lineLengths = lines.map(s -> s.length());
    int totalLength = lineLengths.reduce((a, b) -> a + b);

    第一行定义了一个来自外部文件的基本RDD。 这个数据集并未加载到内存中或做其他处理:lines 仅仅是一个指向文件的指针。 第二行将lineLength定义为map转换函数的结果。 其次,由于转换函数的惰性(lazy),lineLengths不会立即计算。 最后,我们运行reduce,这是一个动作函数。 此时,Spark 把计算分成多个任务(task),并且让它们运行在多台机器上。每台机器都运行自己的 map 和本地 reduce。然后仅仅将结果返回给驱动程序。

    如果稍后还会再次使用lineLength,我们可以在运行reduce之前添加:

    lineLengths.persist(StorageLevel.MEMORY_ONLY());

    这将导致lineLength在第一次计算之后被保存在内存中。

    2. 传递函数给Spark

    Spark的API很大程度上依赖于驱动程序中传递过来的函数在集群上运行。 在Java中,函数由org.apache.spark.api.java.function接口实现。 创建这样的功能有两种方法:

    (1)在类中实现Function接口,作为匿名内部类或命名的内部类,并将其实例传递给Spark。
    (2)在Java 8中,使用lambda表达式来简洁地定义一个实现。

    匿名内部类

    JavaRDD<String> lines = sc.textFile("data.txt");
    JavaRDD<Integer> lineLengths = lines.map(new Function<String, Integer>() {
      public Integer call(String s) { return s.length(); }
    });
    int totalLength = lineLengths.reduce(new Function2<Integer, Integer, Integer>() {
      public Integer call(Integer a, Integer b) { return a + b; }
    });

    或者命名内部类

    class GetLength implements Function<String, Integer> {
      public Integer call(String s) { return s.length(); }
    }
    class Sum implements Function2<Integer, Integer, Integer> {
      public Integer call(Integer a, Integer b) { return a + b; }
    }
    
    JavaRDD<String> lines = sc.textFile("data.txt");
    JavaRDD<Integer> lineLengths = lines.map(new GetLength());
    int totalLength = lineLengths.reduce(new Sum());

    下表中列出一些基本的函数接口:

    函数名实现的方法用途
    Function<T,R>R call(T)接收一个输入值并返回一个输出值,用于类似map()和filter()等操作中
    Function2<T1,T2,R>R call(T1,T2)接收两个输入值并返回一个输出值,用于类似aggregate()和fold()等操作中
    FlatMapFunction<T,R>Iterable<R> call(T)接收一个输入值并返回任意个输出,用于类似flatMap()这样的操作中

    3. 使用键值对

    虽然大多数Spark操作适用于包含任何类型对象的RDD上,但是几个特殊操作只能在键值对的RDD上使用。 最常见的是分布式“shuffle”操作,例如按键分组或聚合元素。

    在Java中,使用Scala标准库中的scala.Tuple2类来表示键值对。 可以如下简单地调用:

    new Tuple2(a,b)

    来创建一个元组,然后用tuple._1()和tuple._2()访问它的字段。

    键值对的RDD由JavaPairRDD类表示。 您可以使用特殊版本的map操作(如mapToPair和flatMapToPair)从JavaRDD来构建JavaPairRDD。 JavaPairRDD将具有标准的RDD的函数以及特殊的键值对函数。

    例如,以下代码在键值对上使用reduceByKey操作来计算每行文本在文件中的出现次数:

    JavaRDD<String> lines = sc.textFile("data.txt");
    JavaPairRDD<String, Integer> pairs = lines.mapToPair(s -> new Tuple2(s, 1));
    JavaPairRDD<String, Integer> counts = pairs.reduceByKey((a, b) -> a + b);

    例如,我们也可以使用counts.sortByKey()来按字母顺序来对键值对排序,最后将counts.collect()作为对象数组返回到驱动程序。

    注意:当使用一个自定义对象作为 key 在使用键值对操作的时候,你需要确保自定义 equals() 方法和 hashCode() 方法是匹配的。更加详细的内容,查看 Object.hashCode() 文档)中的契约概述。

    4. 转换操作(Transformations)

    下面列出了Spark支持的一些常见转换函数。 有关详细信息,请参阅RDD API文档(Scala,Java,Python,R)和RDD函数doc(Scala,Java)。

    4.1 map(func) 映射

    将函数应用于RDD中的每个元素,将返回值构成新的RDD。

    List<String> aList = Lists.newArrayList("a", "B", "c", "b");
    JavaRDD<String> rdd = sc.parallelize(aList);
    // 小写转大写
    JavaRDD<String> upperLinesRDD = rdd.map(new Function<String, String>() {
        @Override
        public String call(String str) throws Exception {
            if (StringUtils.isBlank(str)) {
                return str;
            }
            return str.toUpperCase();
        }
    });
    // A B C B

    4.2 filter(func) 过滤

    返回通过选择func返回true的元素形成的新RDD。

    List<String> list = Lists.newArrayList("a", "B", "c", "b");
    JavaRDD<String> rdd = sc.parallelize(list);
    // 只返回以a开头的字符串
    JavaRDD<String> filterRDD = rdd.filter(new Function<String, Boolean>() {
        @Override
        public Boolean call(String str) throws Exception {
            return !str.startsWith("a");
        }
    });
    // B c b

    4.3 flatMap(func) 一行转多行

    类似于map函数,但是每个输入项可以映射为0个输出项或更多输出项(所以func应该返回一个序列而不是一个条目)。

    List<String> list = Lists.newArrayList("a 1", "B 2");
    JavaRDD<String> rdd = sc.parallelize(list);
    // 一行转多行 以空格分割
    JavaRDD<String> resultRDD = rdd.flatMap(new FlatMapFunction<String, String>() {
        @Override
        public Iterator<String> call(String s) throws Exception {
            if (StringUtils.isBlank(s)) {
                return null;
            }
            String[] array = s.split(" ");
            return Arrays.asList(array).iterator();
        }
    });
    // a
    // 1
    // B
    // 2

    4.4 distinct([numTasks]))

    去重

    List<String> aList = Lists.newArrayList("1", "3", "2", "3");
    JavaRDD<String> aRDD = sc.parallelize(aList);
    // 去重
    JavaRDD<String> rdd = aRDD.distinct(); // 1 2 3

    4.5 union(otherDataset) 并集

    生成一个包含两个RDD中所有元素的RDD. 如果输入的RDD中有重复数据,union()操作也会包含这些重复的数据.

    List<String> aList = Lists.newArrayList("1", "2", "3");
    List<String> bList = Lists.newArrayList("3", "4", "5");
    JavaRDD<String> aRDD = sc.parallelize(aList);
    JavaRDD<String> bRDD = sc.parallelize(bList);
    // 并集
    JavaRDD<String> rdd = aRDD.union(bRDD); // 1 2 3 3 4 5

    4.6 intersection(otherDataset) 交集

    求两个RDD共同的元素的RDD. intersection()在运行时也会去掉所有重复的元素,尽管intersection()与union()的概念相似,但性能却差的很多,因为它需要通过网络混洗数据来发现共同的元素.

    List<String> aList = Lists.newArrayList("1", "2", "3");
    List<String> bList = Lists.newArrayList("3", "4", "5");
    JavaRDD<String> aRDD = sc.parallelize(aList);
    JavaRDD<String> bRDD = sc.parallelize(bList);
    // 交集
    JavaRDD<String> rdd = aRDD.intersection(bRDD); // 3

    4.7 subtract(otherDataset) 差集

    subtract接受另一个RDD作为参数,返回一个由只存在第一个RDD中而不存在第二个RDD中的所有元素组成的RDD

    List<String> aList = Lists.newArrayList("1", "2", "3");
    List<String> bList = Lists.newArrayList("3", "4", "5");
    JavaRDD<String> aRDD = sc.parallelize(aList);
    JavaRDD<String> bRDD = sc.parallelize(bList);
    // 差集
    JavaRDD<String> rdd = aRDD.subtract(bRDD); // 1 2

    4.8 groupByKey 分组

    根据键值对的key进行分组.对(K,V)键值对的数据集进行调用时,返回(K,Iterable <V>)键值对的数据集。

    注意

    如果分组是为了在每个key上执行聚合(如求总和或平均值),则使用reduceByKey或aggregateByKey会有更好的性能。

    默认情况下,输出中的并行级别取决于父RDD的分区数。 可以设置可选参数numTasks来设置任务数量(By default, the level of parallelism in the output depends on the number of partitions of the parent RDD. You can pass an optional numTasks argument to set a different number of tasks.)。

    Tuple2<String, Integer> t1 = new Tuple2<String, Integer>("Banana", 10);
    Tuple2<String, Integer> t2 = new Tuple2<String, Integer>("Pear", 5);
    Tuple2<String, Integer> t3 = new Tuple2<String, Integer>("Banana", 9);
    Tuple2<String, Integer> t4 = new Tuple2<String, Integer>("Apple", 4);
    List<Tuple2<String, Integer>> list = Lists.newArrayList();
    list.add(t1);
    list.add(t2);
    list.add(t3);
    list.add(t4);
    JavaPairRDD<String, Integer> rdd = sc.parallelizePairs(list);
    // 分组
    JavaPairRDD<String, Iterable<Integer>> groupRDD = rdd.groupByKey();
    
    // Apple --- 4
    // Pear --- 5
    // Banana --- 10 9

    4.9 reduceByKey(func, [numTasks]) 分组聚合

    当在(K,V)键值对的数据集上调用时,返回(K,V)键值对的数据集,其中使用给定的reduce函数func聚合每个键的值,该函数类型必须是(V,V)=> V。

    类似于groupByKey,可以通过设置可选的第二个参数来配置reduce任务的数量。

    Tuple2<String, Integer> t1 = new Tuple2<String, Integer>("Banana", 10);
    Tuple2<String, Integer> t2 = new Tuple2<String, Integer>("Pear", 5);
    Tuple2<String, Integer> t3 = new Tuple2<String, Integer>("Banana", 9);
    Tuple2<String, Integer> t4 = new Tuple2<String, Integer>("Apple", 4);
    List<Tuple2<String, Integer>> list = Lists.newArrayList();
    list.add(t1);
    list.add(t2);
    list.add(t3);
    list.add(t4);
    JavaPairRDD<String, Integer> rdd = sc.parallelizePairs(list);
    // 分组计算
    JavaPairRDD<String, Integer> reduceRDD = rdd.reduceByKey(new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
            return v1 + v2;
        }
    });
    
    // Apple --- 4
    // Pear --- 5
    // Banana --- 19

    5. 动作操作 (Action)

    下面列出了Spark支持的一些常见操作。

    5.1 reduce

    接收一个函数作为参数,这个函数要操作两个相同元素类型的RDD并返回一个同样类型的新元素.

    List<String> aList = Lists.newArrayList("aa", "bb", "cc", "dd");
    JavaRDD<String> rdd = sc.parallelize(aList);
    String result = rdd.reduce(new Function2<String, String, String>() {
        @Override
        public String call(String v1, String v2) throws Exception {
            return v1 + "#" + v2;
        }
    });
    System.out.println(result); // aa#bb#cc#dd

    5.2 collect

    将整个RDD的内容返回.

    List<String> list = Lists.newArrayList("aa", "bb", "cc", "dd");
    JavaRDD<String> rdd = sc.parallelize(list);
    List<String> collect = rdd.collect();
    System.out.println(collect); // [aa, bb, cc, dd]

    5.3 take(n)

    返回RDD中的n个元素,并且尝试只访问尽量少的分区,因此该操作会得到一个不均衡的集合.需要注意的是,这些操作返回元素的顺序与你的预期可能不一样.

    List<String> list = Lists.newArrayList("aa", "bb", "cc", "dd");
    JavaRDD<String> rdd = sc.parallelize(list);
    List<String> collect = rdd.take(3);
    System.out.println(collect); // [aa, bb, cc]

    5.5 takeSample

    有时需要在驱动器程序中对我们的数据进行采样,takeSample(withReplacement, num, seed)函数可以让我们从数据中获取一个采样,并指定是否替换.

    版本

    2.1.1

    原文:http://spark.apache.org/docs/latest/programming-guide.html#rdd-operations

    展开全文
  • [Spark]Spark RDD 指南一 引入Spark

    千次阅读 2017-06-08 16:36:51
    2.3.0版本:Spark2.3.0 引入Spark1. Java版Spark 2.1.1适用于Java 7及更高版本。 如果您使用的是Java 8,则Spark支持使用lambda表达式来简洁地编写函数,否则可以使用org.apache.spark.api.java.function包中的类。...

    2.3.0版本Spark2.3.0 引入Spark

    1. Java版

    Spark 2.1.1适用于Java 7及更高版本。 如果您使用的是Java 8,则Spark支持使用lambda表达式来简洁地编写函数,否则可以使用org.apache.spark.api.java.function包中的类。

    请注意,从Spark 2.0.0开始,不支持Java 7,并且可能会在Spark 2.2.0中删除(Note that support for Java 7 is deprecated as of Spark 2.0.0 and may be removed in Spark 2.2.0)。

    要在Java中编写Spark应用程序,您需要在Spark上添加依赖关系。 Spark可通过Maven 仓库获得:

    groupId = org.apache.spark
    artifactId = spark-core_2.11
    version = 2.1.0

    另外,如果希望访问HDFS集群,则需要根据你的HDFS版本添加hadoop-client的依赖:

    groupId = org.apache.hadoop
    artifactId = hadoop-client
    version = <your-hdfs-version>

    最后,您需要将一些Spark类导入到程序中。 添加以下行:

    import org.apache.spark.SparkConf;
    import org.apache.spark.api.java.JavaRDD;
    import org.apache.spark.api.java.JavaSparkContext;

    2. Scala版

    默认情况下,Spark 2.1.1在Scala 2.11上构建并分布式运行(Spark 2.1.1 is built and distributed to work with Scala 2.11 by default)。 (Spark可以与其他版本的Scala一起构建。)要在Scala中编写应用程序,您将需要使用兼容的Scala版本(例如2.11.X)。

    要在Java中编写Spark应用程序,您需要在Spark上添加依赖关系。 Spark可通过Maven 仓库获得:

    groupId = org.apache.spark
    artifactId = spark-core_2.11
    version = 2.1.1

    另外,如果希望访问HDFS集群,则需要根据你的HDFS版本添加hadoop-client的依赖:

    groupId = org.apache.hadoop
    artifactId = hadoop-client
    version = <your-hdfs-version>

    最后,您需要将一些Spark类导入到程序中。 添加以下行:

    import org.apache.spark.SparkContext
    import org.apache.spark.SparkConf

    备注

    在Spark 1.3.0之前,您需要显式导入org.apache.spark.SparkContext._才能启用基本的隐式转换。

    原文:http://spark.apache.org/docs/latest/programming-guide.html#linking-with-spark

    展开全文
  • groupby 测试 在测试了了 筛选(select),join, groupby之后发现 RDD:无论什么时候都是最快的 Dataframe 和SQL的速度基本上一样

    groupby 测试

     

    在测试了了 筛选(select),join, groupby之后发现

     

    RDD:无论什么时候都是最快的

    Dataframe 和SQL的速度基本上一样

    展开全文
  • Spark RDD

    千次阅读 2016-11-23 20:05:18
    RDD是为了处理迭代算法和交互式数据发掘工具应运而生的,keep 数据在内存,显著提升性能.

    概要

    • RDD是为了处理迭代算法和数据发掘应运而生的,keep 数据在内存,显著提升性能。
    • RDD基于lineage实现容错,而不是shared state的update。

    简介

    • 背景
      原有的并行框架如mr无法有效利用内存,并且不能重复利用迭代计算的中间结果,而是将中间结果存储在磁盘上,增加了数据备份(hdfs默认为3份)开销,磁盘IO,序列化的时间,迭代计算在数据挖掘和图算法中很常见,例如K-means,逻辑回归,PageRank。
    • 挑战
      RDD设计中的主要挑战是提供高效的“fault tolerance”编程接口,现有的对于内存存储的容错都是细粒度的对于可变状态的update,具体为跨机器的数据备份(replicate data cross machines )或者跨机器的日志更新( log updates cross machines),需要跨机器传输备份数据,效率低。不同的,RDD提供基于粗粒度的transformations(例如map,filter等)构建的lineage,如果一个RDD丢失数据,则可根据lineage找出丢失数据的来源,从新计算,达到容错,而不需要数据备份。

    RDD(Resilient Distributed Datasets)

    • RDD抽象
      只读的,分区的数据集(a collection of Java or Python objects partitioned across a cluster.),通过其他RDD或者数据源(data in stable storage)创建。RDD通过lineage保留自身创建信息,RDD只有在执行action之后才会触发真正的计算。
    • spark 编程接口
      spark的实现中,使用对象存储数据,transformation是操作这些对象的方法,RDD可以通过外部数据源或者parallelize操作数组的方式初始化,执行transformation获得新RDD,最后是action操作(例如count,collect,save),spark中RDD的计算是lazy的,此外程序可以使用persist和cache(cache是调用persist(StorageLevel.MEMORY_ONLY) )缓存数据达到重复利用。
    • RDD和shared state对比

      上图有几个重要信息,因为RDD是只读的(不可变的)和使用了lineage,一致性和容错得到了保障,对于stragglers(是指long-running tasks,slow nodes)的策略和mapreduce相似,使用了备份任务,同时执行的方式,此外,跟性能相关性大的一点是计算跟着数据走。
    • RDD模型优势
      1. 容错方式:
        RDD只能通过粗粒度的transformation操作,这确保RDD可以bulk write,不需要通过checkpoint就能实现数据容错,此外,只有丢失数据的partition需要重算,根据lineage。
      2. 任务备份:
        通过对运行慢的任务进行备份,提高任务的执行速度。
      3. 就近执行:
        计算跟着数据走,提高执行效率。
      4. 不只是内存:
        内存不足,数据可以存储在硬盘,并通过压缩的方式获得和内存处理相近的性能。
    • RDD不是万能的
      RDD适合批处理,不适合细粒度的对于shared state的update,如web程序的DB,持续增长的web爬虫数据存储等。

    Spark 编程接口

    • RDD相关操作

      spark采用scala语言实现,简洁,效率不错

    RDD组成

    • 组成

    • RDD分类
      窄依赖:父RDD只被一个子RDD引用
      宽依赖:父RDD被不止一个子RDD引用

    • 为什么要区分窄依赖和宽依赖

      1. 窄依赖可以流水线(pipeline)执行,执行效率高,宽依赖需要等所有父RDD执行完再进行下一步计算。
      2. 窄依赖的恢复更容易且快速,因为只有一个父RDD的partition需要重新计算。

      所以,区分RDD类型有助于提高总体的计算效率。

    • 部分RDD的实现
      1. hadoopRDD:
        一个block对应一个partition, preferredLocations方法返回block, 然后iterator reads the block。
      2. mapRDD:
        map方法返回mapRDD, 保持和父RDD相同的partition和preferredLocations,只是将map方法应用于父RDD的每一条记录。
      3. unionRDD:
        union方法返回,每一个child RDD的partition通过窄依赖计算得来。
      4. sampleRDD:
        和map相似,多了一个随机数生成器,用来获取样本RDD中记录
      5. joinRDD:
        可能导致两个宽依赖,两个窄依赖,或者各有一个,result RDD拥有的partition schema,可以是默认的hash partitioner,或者从父RDD继承的

    任务调度

    • stage划分

      当调用action方法时,spark根据lineage构建DAG生成task。如上图所示,以RDD的partition为最小粒度,划分stage时,从一个RDD开始,尽可能多的包含流水线操作(窄依赖),将其划分为一个stage(如上图stage2),每个stage的边界是shuffle操作(宽依赖)。
      对于宽依赖,会保存中间结果便于遇到错误后数据恢复,和mapreduce的map端相似。
    • 任务调度
      stage划分完毕后,根据stage生成一系列task,使用delay scheduling算法,根据计算跟数据走的原则分发task到各节点执行,计算后的结果返给driver节点的action操作。
    • 内存管理
      spark提供三种RDD持久化方案

      1. 内存存储序列化的java对象
      2. 内存存储其他格式的序列化数据
      3. 磁盘存储

      第一种性能最好,第二种选择合适的序列化和压缩工具能更有效利用内存,第三种适用特别大的数据量。为了更有效的使用内存,使用LRU算法,然而,内存不足时,清除的却是最近被使用的RDD的partition,保存old partition在内存,目的是为了防止partition频繁的in and out。因为我们通常操作整个RDD,那么早已在内存中的partition将来被用到的可能性大。目前spark集群的每个实例单独管理自己的 memory,未来调研统一内存管理的可行性(unified memory manager)。

    • 支持保存点(checkpoint)
      虽然RDD可以通过lineage实现fault recovery,但是这个恢复可能是很耗时的,因此提供保存点很有必要,通常保存点在有宽依赖时(shuffle耗时)很有用,相反,窄依赖时则不值得使用。spark提供了API ,但何时使用由用户决定,也在调研自动保存点的可行性,RDD的只读属性也使其实现保存点功能比传统的shared state更容易。

    总结

    RDD是高效的,通用的,容错的,更是spark的基石。

    参考: Resilient Distributed Datasets: A Fault-Tolerant Abstraction for
    In-Memory Cluster Computing

    展开全文
  • spark RDD

    2016-05-16 17:51:27
    命令行下如果需要绑定文件路径需要使用如下方式val textFile = sc....file:///letv/data/spark-1.5.0-bin-hadoop2.6/README.md&amp;amp;amp;amp;quot;)参考: http://colobu.com/2014/12/08/spark-quick-start/
  • sparkRDD

    千次阅读 2017-12-11 19:37:12
    RDDRDD弹性分布式数据集,spark最基本的数据抽象,代表一个不可变,可分区,里面元素可并行计算的集合。 具有数据流模型的特点:自动容错,位置感知性调度和可伸缩性。 RDD允许用户在执行多个查询时,显示地将工作集...
  • spark rdd

    2016-05-03 17:50:02
    RDD是弹性分布式数据集,即一个RDD代表一个被分区的只读数据集。一个RDD生成有两种途径,一个来自于内存集合和外部存储系统,另一种是通过转换操作来自于其他RDD,比如:map、filter、jion等。  RDD分区:对于一个...
  • Spark RDD基础

    万次阅读 2018-11-30 14:17:24
    Spark RDD基础 IDEA 创建scala spark的Mvn项目:https://blog.csdn.net/u014646662/article/details/84618032 spark快速大数据分析.pdf下载:https://download.csdn.net/download/u014646662/10816588 弹性分布式...
  • 深入理解Spark RDD——RDD信息对象

    千次阅读 2019-08-16 11:20:53
    RDDInfo用于描述RDD的信息,RDDInfo提供的信息如下: id:RDD的id。 name:RDD的名称。 numPartitions:RDD的分区数量。 storageLevel:RDD的存储级别(即StorageLevel)。 parentIds:RDD的父亲RDD的id序列。...
  • Spark RDD简单操作

    万次阅读 2018-11-30 15:45:55
    Spark RDD操作 spark快速大数据分析.pdf下载:https://download.csdn.net/download/u014646662/10816588 IDEA 创建scala spark的Mvn项目:https://blog.csdn.net/u014646662/article/details/84618032 1、Spark ...
  • Spark RDD与Partion

    万次阅读 2018-09-18 11:22:30
    RDD(Resilient Distributed Dataset)叫做弹性分布式数据集,是Spark中最基本的数据抽象,它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点:自动容错、位置感知性调度和可伸缩性。...
  • Spark RDD 持久化

    千次阅读 2019-04-29 20:00:48
    目录 一:应用情景 二:持久化的作用方式 三:实操 ...1.再次对同一个RDD进行计算时,会复用已经持久化的RDD,不用从HDFS上重新装载数据生成 2.持久化的自动容错机制: 在持久化的RDD的任何partit...
  • Spark RDD API详解

    2017-01-03 21:13:33
    1. RDD简单介绍 RDDSpark中的抽象数据结构类型,任何数据在Spark中都被表示为RDD。从编程的角度来看,RDD可以简单看成是一个数组。和普通数组的区别是,RDD中的数据是分区存储的,这样不同分区的数据就可以分布在...
  • Spark RDD核心详解

    千次阅读 2018-05-04 22:32:04
    对于spark 来说,其核心是RDD(Resilient Distributed Dataset,弹性分布式数据集),它是一种特殊的集合,支持多种来源,有容错机制,可以被缓存支持并行操作。下面来看看RDD这一抽象数据集的核心。 Spark编程...
  • 在《深入理解Spark RDD——RDD依赖(构建DAG的关键)》一文,详细描述了RDD的宽窄依赖。RDD之间的依赖关系如果是Shuffle依赖,那么上游RDD该如何确定每个分区的输出将交由下游RDD的哪些分区呢?或者下游RDD的各个...
  • spark API RDD

    2014-09-05 16:18:26
    spark API RDD pdf版的..........对初学者应该有所帮助
  • SparkRDD操作

    千次阅读 2016-10-09 20:38:30
    根据传入的函数处理原有的RDD对象中每一个元素,每一个新元素处理完成后返回一个对象,这些新对象组装得到一个新的RDD,新的RDD和旧的RDD元素都是一一对应的 filter(func) 根据传入的函数来过滤RDD中每一个元素,...
  • 理解SparkRDD

    万次阅读 2014-11-23 20:57:54
    RDD(Resilient Distributed Datasets)弹性分布式数据集,是在集群应用中分享数据的一种高效,通用,容错的抽象,是Spark提供的最重要的抽象的概念,它是一种有容错机制的特殊集合,可以分布在集群的节点上,以函数...
  • Spark2.3.0 版本: Spark2.3.0 创建RDDSpark的核心概念是弹性分布式数据集(RDD),RDD是一个可容错、可并行操作的分布式元素集合。有两种方法可以创建RDD对象:在驱动程序中并行化操作集合对象来创建RDD从外部存储...
  • Spark DAG与RDD

    千次阅读 2018-09-17 13:45:02
    1、DAG DAG图中,每个节点都是RDD ...从子RDD角度看:依赖上级RDD的部分分区 精确知道依赖的上级RDD分区,会选择和自己在同一节点的上级RDD分区,没有网络IO开销,高效。 窄依赖包括: OneToOneDepen...
  • Spark RDDSpark中的地位和作用如何?

    千次阅读 2020-04-17 11:53:47
    一 为什么会有Spark? 因为传统的并行计算模型...其主要实现思想就是RDD,把所有计算的数据保存在分布式的内存中.迭代计算通常情况下都是对同一个数据集做反复的迭代计算,数据在内存中将大大提升IO操作.这也是Spa...

空空如也

1 2 3 4 5 ... 20
收藏数 25,054
精华内容 10,021
关键字:

rdd