ErBing

往事已经定格,未来还要继续。

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

一、概述

  Apache Spark 是一个快速的, 多用途的集群计算系统。 它提供了 Java, Scala, Python 和 R 的高级 API,以及一个支持通用的执行图计算的优化过的引擎. 它还支持一组丰富的高级工具, 包括使用 SQL 处理结构化数据处理的 Spark SQL, 用于机器学习的 MLlib, 用于图计算的 GraphX, 以及 Spark Streaming。

  请注意, 在 Spark 2.0 之前, Spark 的主要编程接口是弹性分布式数据集(RDD)。 在 Spark 2.0 之后, RDD 被 Dataset 替换, 它是像RDD 一样的 strongly-typed(强类型), 但是在引擎盖下更加优化。 RDD 接口仍然受支持,但是, 我们强烈建议您切换到使用 Dataset(数据集), 其性能要更优于 RDD。

  每一个 Spark 应用程序由一个在集群上运行着用户的 main 函数和执行各种并行操作的 driver program(驱动程序)组成。Spark 提供的主要抽象是一个弹性分布式数据集(RDD),它是可以执行并行操作且跨集群节点的元素的集合。RDD 可以从一个 Hadoop 文件系统(或者任何其它 Hadoop 支持的文件系统),或者一个在 driver program(驱动程序)中已存在的 Scala 集合,以及通过 transforming(转换)来创建一个 RDD。用户为了让它在整个并行操作中更高效的重用,也许会让 Spark persist(持久化)一个 RDD 到内存中。最后,RDD 会自动的从节点故障中恢复。

  在 Spark 中的第二个抽象是能够用于并行操作的 shared variables(共享变量),默认情况下,当 Spark 的一个函数作为一组不同节点上的任务运行时,它将每一个变量的副本应用到每一个任务的函数中去。有时候,一个变量需要在整个任务中,或者在任务和 driver program(驱动程序)之间来共享。Spark 支持两种类型的共享变量 : broadcast variables(广播变量),它可以用于在所有节点上缓存一个值,和 accumulators(累加器),他是一个只能被 “added(增加)” 的变量,例如 counters 和 sums。

二、Spark依赖

  Spark 2.x 默认使用 Scala 2.11 来构建和发布直到运行。(当然,Spark 也可以与其它的 Scala 版本一起运行)。为了使用 Scala 编写应用程序,您需要使用可兼容的 Scala 版本(例如,2.11.X)。

  要编写一个 Spark 的应用程序,您需要在 Spark 上添加一个 Maven 依赖。Spark 可以通过 Maven 中央仓库获取:

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

  此外,如果您想访问一个 HDFS 集群,则需要针对您的 HDFS 版本添加一个 hadoop-client(hadoop 客户端)依赖。

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

  最后,您需要导入一些 Spark classes(类)到您的程序中去。添加下面几行:

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

三、初始化Spark

  Spark 程序必须做的第一件事情是创建一个 SparkContext 对象,它会告诉 Spark 如何访问集群。要创建一个 SparkContext,首先需要构建一个包含应用程序的信息的 SparkConf 对象。

SparkConf conf = new SparkConf().setAppName(appName).setMaster(master);
JavaSparkContext sc = new JavaSparkContext(conf);

  这个 appName 参数是一个在集群 UI 上展示应用程序的名称。 master 是一个 Spark, Mesos 或 YARN 的 cluster URL,或者指定为在 local mode(本地模式)中运行的 “local” 字符串。在实际工作中,当在集群上运行时,您不希望在程序中将 master 给硬编码,而是用 使用 spark-submit 启动应用并且接收它。然而,对于本地测试和单元测试,您可以通过 “local” 来运行 Spark 进程。

四、弹性分布式数据集 (RDDs)

  Spark 主要以一个 弹性分布式数据集(RDD)的概念为中心,它是一个容错且可以执行并行操作的元素的集合。有两种方法可以创建 RDD : 在你的 driver program(驱动程序)中 parallelizing 一个已存在的集合,或者在外部存储系统中引用一个数据集,例如,一个共享文件系统,HDFS,HBase,或者提供 Hadoop InputFormat 的任何数据源。

1、A list of partiotions
一组分区(partition),partiotion是一个具体概念,指在一个节点中的连续的空间。一个partiotione肯定使在一个节点上,但是一个节点上可以有多个partiotione。用户可以在创建RDD时指定RDD的分区个数。
2、A function for computing each split
对RDD做计算,相当于对RDD的每个split或partition做计算
3、A list of dependencies on other RDDs
RDD之间有依赖关系,可溯源。
依赖还具体分为宽依赖和窄依赖,但并不是所有的RDD都有依赖。 
RDD的每次转换都会生成一个新的RDD,所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时,Spark可以通过这个依赖关系重新计算丢失的分区数据,而不是对RDD的所有分区进行重新计算。
4、Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
可以按key的hash值分区
5、Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)
数据本地性。计算每个split时,在split所在机器的本地上运行task是最好的,避免了数据的移动;split有多个副本,所以preferred location不止一个
RDD五大特性

 4.1创建RDD

  • 并行集合

  可以在您的 driver program (a Scala Seq) 中已存在的集合上通过调用 SparkContext 的 parallelize 方法来创建并行集合。该集合的元素从一个可以并行操作的 distributed dataset(分布式数据集)中复制到另一个 dataset(数据集)中去。例如,这里是一个如何去创建一个保存数字 1 ~ 5 的并行集合。

List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
JavaRDD<Integer> distData = sc.parallelize(data);

  在创建后,该 distributed dataset(分布式数据集)(distData)可以并行的执行操作。例如,我们可以调用 distData.reduce((a, b) => a + b) 来合计数组中的元素。后面我们将介绍 distributed dataset(分布式数据集)上的操作。

  并行集合中一个很重要参数是 partitions(分区)的数量,它可用来切割 dataset(数据集)。Spark 将在集群中的每一个分区上运行一个任务。通常您希望群集中的每一个 CPU 计算 2-4 个分区。一般情况下,Spark 会尝试根据您的群集情况来自动的设置的分区的数量。当然,您也可以将分区数作为第二个参数传递到 parallelize (例如sc.parallelize(data, 10)) 方法中来手动的设置它。

  • 外部 Datasets(数据集)

  Spark 可以从 Hadoop 所支持的任何存储源中创建 distributed dataset(分布式数据集),包括本地文件系统,HDFS,Cassandra,HBase,Amazon S3 等等。 Spark 支持文本文件,SequenceFiles,以及任何其它的 Hadoop InputFormat。

  可以使用 SparkContext 的 textFile 方法来创建文本文件的 RDD。此方法需要一个文件的 URI(计算机上的本地路径 ,hdfs://s3n:// 等等的 URI),并且读取它们作为一个 lines(行)的集合。下面是一个调用示例:

JavaRDD<String> distFile = sc.textFile("data.txt");

  使用 Spark 读取文件时需要注意:

    • 所有 Spark 基于文件的 input 方法, 包括 textFile, 支持在目录上运行, 压缩文件, 和通配符. 例如, 您可以使用 textFile("/my/directory")textFile("/my/directory/*.txt"), and textFile("/my/directory/*.gz").

    • textFile 方法也可以通过第二个可选的参数来控制该文件的分区数量. 默认情况下, Spark 为文件的每一个 block(块)创建的一 个 partition 分区(HDFS 中块大小默认是 128MB),当然你也可以通过传递一个较大的值来要求一个较高的分区数量。请注意,分区的数量不能够小于块的数量。

  除了文本文件之外,Spark 也支持一些其它的数据格式:

    • JavaSparkContext.wholeTextFile 可以读取包含多个小文本文件的目录, 并且将它们作为一个 (filename, content) pairs 来返回. 这与 textFile 相比, 它的每一个文件中的每一行将返回一个记录. 分区由数据量来确定, 某些情况下, 可能导致分区太少. 针对这些情况, wholeTextFiles 在第二个位置提供了一个可选的参数用户控制分区的最小数量.
    • 针对 SequenceFiles, 使用 SparkContext 的 sequenceFile[K, V] 方法,其中 K 和 V 指的是文件中 key 和 values 的类型. 这些应该是 Hadoop 的 Writable 接口的子类, 像 IntWritable and Text. 此外, Spark 可以让您为一些常见的 Writables 指定原生类型; 例如, sequenceFile[Int, String]会自动读取 IntWritables 和 Texts.
    • 针对其它的 Hadoop InputFormats, 您可以使用 SparkContext.hadoopRDD 方法, 它接受一个任意的 JobConf 和 input format class, key class 和 value class. 通过相同的方法你可以设置你的 input source(输入源). 你还可以针对 InputFormats 使用基于 “new” MapReduce API (org.apache.hadoop.mapreduce) 的 SparkContext.newAPIHadoopRDD.
    • RDD.saveAsObjectFile 和 SparkContext.objectFile 支持使用简单的序列化的 Java objects 来保存 RDD. 虽然这不像 Avro 这种专用的格式一样高效,但其提供了一种更简单的方式来保存任何的 RDD。

 4.2 RDD操作

  RDDs support 两种类型的操作: transformations(转换), 它会在一个已存在的 dataset 上创建一个新的 dataset, 和 actions(动作), 将在 dataset 上运行的计算后返回到 driver 程序. 例如, map 是一个通过让每个数据集元素都执行一个函数,并返回的新 RDD 结果的 transformation。reduce是 通过执行一些函数,聚合 RDD 中所有元素,并将最终结果给返回驱动程序的action.

  Spark 中所有的 transformations 都是 lazy(懒加载的), 因此它不会立刻计算出结果. 他们只应用于一些基本数据集的转换 (例如. 文件). 只有当需要返回结果给驱动程序时(action操作时),transformations 才开始计算. 这种设计使 Spark 的运行更高效.

  默认情况下,每次你在 RDD 运行一个 action 的时, 每个 transformed RDD 都会被重新计算。但是,您也可用 persist (或 cache) 方法将 RDD persist(持久化)到内存中;在这种情况下,Spark 为了下次查询时可以更快地访问,会把数据保存在集群上。此外,还支持持续持久化 RDDs 到磁盘,或复制到多个结点。

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; }
});

  第一行从外部文件中定义了一个基本的 RDD,但这个数据集并未加载到内存中或即将被行动: line 仅仅是一个类似指针的东西,指向该文件. 第二行定义了 lineLengths 作为 map 的结果。请注意,由于 laziness(延迟加载)lineLengths 不会被立即计算. 最后,我们运行 reduce,这是一个 action。此时,Spark 分发计算任务到不同的机器上运行,每台机器都运行 map 的一部分并本地运行 reduce,仅仅返回它聚合后的结果给驱动程序.

  如果我们也希望以后再次使用 lineLengths,我们可以在 reduce 之前添加以下代码,这样它就会被保存在 memory 中。

lineLengths.persist(StorageLevel.MEMORY_ONLY());

  4.2.1 理解闭包

    在集群中执行代码时,一个关于 Spark 更难的事情是理解变量和方法的范围和生命周期。

int counter = 0;
JavaRDD<Integer> rdd = sc.parallelize(data);
// Wrong: Don't do this!!
rdd.foreach(x -> counter += x);
println("Counter value: " + counter);   
  • Local(本地)vs. cluster(集群)模式

    • 上面的代码行为是不确定的,并且可能无法按预期正常工作。执行作业时,Spark 会分解 RDD 操作到每个 executor 中的 task 里。在执行之前,Spark 计算任务的 closure(闭包)。闭包是指 executor 要在RDD上进行计算时必须对执行节点可见的那些变量和方法(在这里是foreach())。闭包被序列化并被发送到每个 executor。
    • 闭包的变量副本发给每个 executor ,当 counter 被 foreach 函数引用的时候,它已经不再是 driver node 的 counter 了。虽然在 driver node 仍然有一个 counter 在内存中,但是对 executors 已经不可见。executor 看到的只是序列化的闭包一个副本。所以 counter 最终的值还是 0,因为对 counter 所有的操作均引用序列化的 closure 内的值。
    • 在 local 本地模式,在某些情况下的 foreach 功能实际上是同一 JVM 上的驱动程序中执行,并会引用同一个原始的 counter 计数器,实际上可能更新值。
    • 如果需要一些全局的聚合功能,应使用 Accumulator(累加器)。当一个执行的任务分配到集群中的各个 worker 结点时,Spark 的累加器是专门提供安全更新变量的机制。
  • 打印 RDD 的 elements
    • 另一种常见的语法用于打印 RDD 的所有元素使用 rdd.foreach(println) 或 rdd.map(println)。在一台机器上,这将产生预期的输出和打印 RDD 的所有元素。
    • 然而,在集群 cluster 模式下,stdout 输出正在被执行写操作 executors 的 stdout 代替,而不是在一个驱动程序上,因此 stdout 的 driver 程序不会显示这些!
    • 要打印 driver 程序的所有元素,可以使用的 collect() 方法首先把 RDD 放到 driver 程序节点上rdd.collect().foreach(println)。这可能会导致 driver 程序耗尽内存,虽说,因为 collect() 获取整个 RDD 到一台机器; 如果你只需要打印 RDD 的几个元素,一个更安全的方法是使用 take()rdd.take(100).foreach(println)

  4.2.2 Key-Value Pairs 

    虽然大多数 Spark 操作工作在包含任何类型对象的 RDDs 上,只有少数特殊的操作可用于 Key-Value 对的 RDDs. 最常见的是分布式 “shuffle” 操作,如通过元素的 key 来进行 grouping 或 aggregating(聚合) 操作。

    在java中, key-value pairs 是使用Scala标准库中的 scala.Tuple2 类来代表,你可以使用new Tuple2(a, b) 来创建一个Tuple,访问它的元素使用tuple._1() 和 tuple._2()

    可以使用 mapToPair 和 flatMapToPair将JavaRDDs转换为JavaPairRDDs.

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() 把他们作为一个数据对象返回给 driver 程序。

    当在 key-value pair 操作中使用自定义的 objects 作为 key 时, 您必须确保有一个自定义的 equals() 方法和一个 hashCode() 方法。

4.3 算子  

Transformations(转换)

下表列出了一些 Spark 常用的 transformations(转换). 详情请参考 RDD API 文档 (Scala, Java, Python, R) 和 pair RDD 函数文档 (Scala, Java).

Transformation(转换)Meaning(含义)
map(func) 返回一个新的 distributed dataset(分布式数据集),它由每个 source(数据源)中的元素应用一个函数 func 来生成.
filter(func) 返回一个新的 distributed dataset(分布式数据集),它由每个 source(数据源)中应用一个函数 func 且返回值为 true 的元素来生成.
flatMap(func) 与 map 类似,但是每一个输入的 item 可以被映射成 0 个或多个输出的 items(所以 func 应该返回一个 Seq 而不是一个单独的 item).
mapPartitions(func) 与 map 类似,但是单独的运行在在每个 RDD 的 partition(分区,block)上,所以在一个类型为 T 的 RDD 上运行时 func 必须是 Iterator<T> => Iterator<U> 类型.(一次处理一个partition的数据,当不会内存溢出时可代替map,减少如数据库连接等次数)
mapPartitionsWithIndex(func) 与 mapPartitions 类似,但是也需要提供一个代表 partition 的 index(索引)的 interger value(整型值)作为参数的 func,所以在一个类型为 T 的 RDD 上运行时 func 必须是 (Int, Iterator<T>) => Iterator<U> 类型.
sample(withReplacementfractionseed) 样本数据,设置是否放回(withReplacement), 采样的百分比(fraction)、使用指定的随机数生成器的种子(seed).
union(otherDataset) 反回一个新的 dataset,它包含了 source dataset(源数据集)和 otherDataset(其它数据集)的并集.
intersection(otherDataset) 返回一个新的 RDD,它包含了 source dataset(源数据集)和 otherDataset(其它数据集)的交集.
distinct([numTasks])) 返回一个新的 dataset,它包含了 source dataset(源数据集)中去重的元素.
groupByKey([numTasks]) 在一个 (K, V) pair 的 dataset 上调用时,返回一个 (K, Iterable<V>) . 
Note: 如果分组是为了在每一个 key 上执行聚合操作(例如,sum 或 average),此时使用 reduceByKey 或 aggregateByKey 来计算性能会更好(shuffle的map之后自带combiner,会执行逻辑运算,同一个parition中的相同key,只用传一次结果到reduce). 
Note: 默认情况下,并行度取决于父 RDD 的分区数。可以传递一个可选的 numTasks 参数来设置不同的任务数.
reduceByKey(func, [numTasks]) 在 (K, V) pairs 的 dataset 上调用时, 返回 dataset of (K, V) pairs 的 dataset, 其中的 values 是针对每个 key 使用给定的函数 func 来进行聚合的, 它必须是 type (V,V) => V 的类型. 像 groupByKey 一样, reduce tasks 的数量是可以通过第二个可选的参数来配置的.
aggregateByKey(zeroValue)(seqOpcombOp, [numTasks]) 在 (K, V) pairs 的 dataset 上调用时, 返回 (K, U) pairs 的 dataset,其中的 values 是针对每个 key 使用给定的 combine 函数以及一个 neutral "0" 值来进行聚合的. 允许聚合值的类型与输入值的类型不一样, 同时避免不必要的配置. 像 groupByKey 一样, reduce tasks 的数量是可以通过第二个可选的参数来配置的.(shuffle的map和reduce逻辑不一样时候,不能用reducebykey,比如求average,不能先在map阶段就取平均,而是整体取平均)
sortByKey([ascending], [numTasks]) 在一个 (K, V) pair 的 dataset 上调用时,其中的 K 实现了 Ordered,返回一个按 keys 升序或降序的 (K, V) pairs 的 dataset, 由 boolean 类型的 ascending 参数来指定.
join(otherDataset, [numTasks]) 在一个 (K, V) 和 (K, W) 类型的 dataset 上调用时,返回一个 (K, (V, W)) pairs 的 dataset,它拥有每个 key 中所有的元素对。Outer joins 可以通过 leftOuterJoinrightOuterJoin 和 fullOuterJoin 来实现.
cogroup(otherDataset, [numTasks]) 在一个 (K, V) 和的 dataset 上调用时,返回一个 (K, (Iterable<V>, Iterable<W>)) tuples 的 dataset. 这个操作也调用了 groupWith.
cartesian(otherDataset) 在一个 T 和 U 类型的 dataset 上调用时,返回一个 (T, U) pairs 类型的 dataset(所有元素的 pairs,即笛卡尔积).
pipe(command[envVars]) 通过使用 shell 命令来将每个 RDD 的分区给 Pipe。例如,一个 Perl 或 bash 脚本。RDD 的元素会被写入进程的标准输入(stdin),并且 lines(行)输出到它的标准输出(stdout)被作为一个字符串型 RDD 的 string 返回.
coalesce(numPartitions) Decrease(降低)RDD 中 partitions(分区)的数量为 numPartitions。对于执行filter后一个大的 dataset 操作是更有效的.默认无shuffle
repartition(numPartitions) Reshuffle(重新洗牌)RDD 中的数据以创建或者更多的 partitions(分区)并将每个分区中的数据尽量保持均匀. 该操作总是通过网络来 shuffles 所有的数据.
repartitionAndSortWithinPartitions(partitioner) 根据给定的 partitioner(分区器)对 RDD 进行重新分区,并在每个结果分区中,按照 key 值对记录排序。这比每一个分区中先调用 repartition 然后再 sorting(排序)效率更高,因为它可以将排序过程推送到 shuffle 操作的机器上进行.

Actions(动作)

下表列出了一些 Spark 常用的 actions 操作。详细请参考 RDD API 文档 (Scala, Java, Python, R)和 pair RDD 函数文档 (Scala, Java).

Action(动作)Meaning(含义)
reduce(func) 使用函数 func 聚合 dataset 中的元素,这个函数 func 输入为两个元素,返回为一个元素。这个函数应该是可交换(commutative )和关联(associative)的,这样才能保证它可以被并行地正确计算.
collect() 在 driver 程序中,以一个 array 数组的形式返回 dataset 的所有元素。这在过滤器(filter)或其他操作(other operation)之后返回足够小(sufficiently small)的数据子集通常是有用的.
count() 返回 dataset 中元素的个数.
first() 返回 dataset 中的第一个元素(类似于 take(1).
take(n) 将数据集中的前 n 个元素作为一个 array 数组返回.
takeSample(withReplacementnum, [seed]) 对一个 dataset 进行随机抽样,返回一个包含 num 个随机抽样(random sample)元素的数组,参数 withReplacement 指定是否有放回抽样,参数 seed 指定生成随机数的种子.
takeOrdered(n[ordering]) 返回 RDD 按自然顺序(natural order)或自定义比较器(custom comparator)排序后的前 n 个元素.
saveAsTextFile(path) 将 dataset 中的元素以文本文件(或文本文件集合)的形式写入本地文件系统、HDFS 或其它 Hadoop 支持的文件系统中的给定目录中。Spark 将对每个元素调用 toString 方法,将数据元素转换为文本文件中的一行记录.
saveAsSequenceFile(path
(Java and Scala)
将 dataset 中的元素以 Hadoop SequenceFile 的形式写入到本地文件系统、HDFS 或其它 Hadoop 支持的文件系统指定的路径中。该操作可以在实现了 Hadoop 的 Writable 接口的键值对(key-value pairs)的 RDD 上使用。在 Scala 中,它还可以隐式转换为 Writable 的类型(Spark 包括了基本类型的转换,例如 Int, Double, String 等等).
saveAsObjectFile(path
(Java and Scala)
使用 Java 序列化(serialization)以简单的格式(simple format)编写数据集的元素,然后使用 SparkContext.objectFile() 进行加载.
countByKey() 仅适用于(K,V)类型的 RDD 。返回具有每个 key 的计数的 (K , Int)pairs 的 hashmap.
foreach(func) 对 dataset 中每个元素运行函数 func 。这通常用于副作用(side effects),例如更新一个 Accumulator(累加器)或与外部存储系统(external storage systems)进行交互。Note:修改除 foreach()之外的累加器以外的变量(variables)可能会导致未定义的行为(undefined behavior)。详细介绍请阅读 Understanding closures(理解闭包) 部分.

4.2.4  shuffle操作

  Spark 里的某些操作会触发 shuffle。shuffle 是spark 重新分配数据的一种机制,使得这些数据可以跨不同的区域进行分组。这通常涉及在 executors和机器之间拷贝数据,这使得 shuffle 成为一个复杂的、代价高的操作。

  为了明白 reduceByKey 操作的过程,我们以 reduceByKey 为例。reduceBykey 操作产生一个新的 RDD,其中 key 所有相同的的值组合成为一个 tuple - key 以及与 key 相关联的所有值在 reduce 函数上的执行结果。面临的挑战是,一个 key 的所有值不一定都在一个同一个 paritition 分区里,甚至是不一定在同一台机器里,但是它们必须共同被计算。

  在 spark 里,特定的操作需要数据不跨分区分布。在计算期间,一个任务在一个分区上执行,为了所有数据都在单个 reduceByKey 的 reduce 任务上运行,我们需要执行一个 all-to-all 操作。它必须从所有分区读取所有的 key 和 key对应的所有的值,并且跨分区聚集去计算每个 key 的结果 - 这个过程就叫做 shuffle.。

  尽管每个分区新 shuffle 的数据集将是确定的,分区本身的顺序也是这样,但是这些数据的顺序是不确定的。如果希望 shuffle 后的数据是有序的,可以使用:

  • mapPartitions 对每个 partition 分区进行排序,例如, .sorted
  • repartitionAndSortWithinPartitions 在分区的同时对分区进行高效的排序.
  • sortBy 对 RDD 进行全局的排序

触发的 shuffle 操作包括 repartition 操作,如 repartition 和 coalesce‘ByKey 操作像 groupByKey 和 reduceByKey, 和 join操作, 像 cogroup 和 join.

4.2.5 RDD Persistence(持久化)

  Spark 中一个很重要的能力是将数据 persisting 持久化(或称为 caching 缓存),在多个操作间都可以访问这些持久化的数据。当持久化一个 RDD 时,每个节点的其它分区都可以使用 RDD 在内存中进行计算,在该数据上的其他 action 操作将直接使用内存中的数据。这样会让以后的 action 操作计算速度加快(通常运行速度会加速 10 倍)。缓存是迭代算法和快速的交互式使用的重要工具。

  RDD 可以使用 persist() 方法或 cache() 方法进行持久化。数据将会在第一次 action 操作时进行计算,并缓存在节点的内存中。Spark 的缓存具有容错机制,如果一个缓存的 RDD 的某个分区丢失了,Spark 将按照原来的计算过程,自动重新计算并进行缓存。

  另外,每个持久化的 RDD 可以使用不同的 storage level 存储级别进行缓存,例如,持久化到磁盘、已序列化的 Java 对象形式持久化到内存(可以节省空间)、跨节点间复制、以 off-heap 的方式存储在 Tachyon。这些存储级别通过传递一个 StorageLevel 对象给 persist() 方法进行设置。cache() 方法是使用默认存储级别的快捷设置方法,默认的存储级别是 StorageLevel.MEMORY_ONLY(将反序列化的对象存储到内存中)。详细的存储级别介绍如下:

Storage Level(存储级别)Meaning(含义)
MEMORY_ONLY 将 RDD 以反序列化的 Java 对象的形式存储在 JVM 中. 如果内存空间不够,部分数据分区将不再缓存,在每次需要用到这些数据时重新进行计算. 这是默认的级别.
MEMORY_AND_DISK 将 RDD 以反序列化的 Java 对象的形式存储在 JVM 中。如果内存空间不够,将未缓存的数据分区存储到磁盘,在需要使用这些分区时从磁盘读取.
MEMORY_ONLY_SER 
(Java and Scala)
将 RDD 以序列化的 Java 对象的形式进行存储(每个分区为一个 byte 数组)。这种方式会比反序列化对象的方式节省很多空间,尤其是在使用 fast serializer 时会节省更多的空间,但是在读取时会增加 CPU 的计算负担.
MEMORY_AND_DISK_SER 
(Java and Scala)
类似于 MEMORY_ONLY_SER ,但是溢出的分区会存储到磁盘,而不是在用到它们时重新计算.
DISK_ONLY 只在磁盘上缓存 RDD.
MEMORY_ONLY_2, MEMORY_AND_DISK_2, etc. 与上面的级别功能相同,只不过每个分区在集群中两个节点上建立副本.
OFF_HEAP (experimental 实验性) 类似于 MEMORY_ONLY_SER, 但是将数据存储在 off-heap memory 中. 这需要启用 off-heap 内存.

  Spark 会自动监视每个节点上的缓存使用情况,并使用 least-recently-used(LRU)的方式来丢弃旧数据分区。 如果您想手动删除 RDD 而不是等待它掉出缓存,使用 RDD.unpersist() 方法。

4.2.6 共享变量

  • 广播变量
    • Broadcast variables(广播变量)允许程序员将一个 read-only(只读的)变量缓存到每台机器上,而不是给任务传递一个副本。它们是如何来使用呢,例如,广播变量可以用一种高效的方式给每个节点传递一份比较大的 input dataset(输入数据集)副本。在使用广播变量时,Spark 也尝试使用高效广播算法分发 broadcast variables(广播变量)以降低通信成本。
    • Spark 的 action(动作)操作是通过一系列的 stage(阶段)进行执行的,这些 stage(阶段)是通过分布式的 “shuffle” 操作进行拆分的。Spark 会自动广播出每个 stage(阶段)内任务所需要的公共数据。这种情况下广播的数据使用序列化的形式进行缓存,并在每个任务运行前进行反序列化。这也就意味着,只有在跨越多个 stage(阶段)的多个任务会使用相同的数据,或者在使用反序列化形式的数据特别重要的情况下,使用广播变量会有比较好的效果。
    • 广播变量通过在一个变量 v 上调用 SparkContext.broadcast(v) 方法来进行创建。广播变量是 v 的一个 wrapper(包装器),可以通过调用 value方法来访问它的值。代码示例如下:
      Broadcast<int[]> broadcastVar = sc.broadcast(new int[] {1, 2, 3});
      broadcastVar.value();
      // returns [1, 2, 3]
    • 在创建广播变量之后,在集群上执行的所有的函数中,应该使用该广播变量代替原来的 v 值,所以节点上的 v 最多分发一次。另外,对象 v 在广播后不应该再被修改,以保证分发到所有的节点上的广播变量具有同样的值。

  • Accumulators(累加器)

    • Accumulators(累加器)是一个仅可以执行 “added”(添加)的变量来通过一个关联和交换操作,因此可以高效地执行支持并行。累加器可以用于实现 counter( 计数,类似在 MapReduce 中那样)或者 sums(求和)。原生 Spark 支持数值型的累加器,并且程序员可以添加新的支持类型。

    • 作为一个用户,您可以创建 accumulators(累加器)并且重命名. 如下图所示, 一个命名的 accumulator 累加器(在这个例子中是 counter)将显示在 web UI 中,用于修改该累加器的阶段。 Spark 在 “Tasks” 任务表中显示由任务修改的每个累加器的值。

    • 可以通过调用 SparkContext.longAccumulator() 或 SparkContext.doubleAccumulator() 方法创建数值类型的 accumulator(累加器)以分别累加 Long 或 Double 类型的值。集群上正在运行的任务就可以使用 add 方法来累计数值。然而,它们不能够读取它的值。只有 driver program(驱动程序)才可以使用 value 方法读取累加器的值。
      LongAccumulator accum = jsc.sc().longAccumulator();
      
      sc.parallelize(Arrays.asList(1, 2, 3, 4)).foreach(x -> accum.add(x));
      // ...
      // 10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s
      
      accum.value();
      // returns 10
    • 虽然此代码使用 Long 类型的累加器的内置支持, 但是开发者通过 AccumulatorV2 它的子类来创建自己的类型. AccumulatorV2 抽象类有几个需要 override(重写)的方法: reset 方法可将累加器重置为 0, add 方法可将其它值添加到累加器中, merge 方法可将其他同样类型的累加器合并为一个. 其他需要重写的方法可参考 API documentation. 例如, 假设我们有一个表示数学上 vectors(向量)的 MyVector 类,我们可以写成:

      class VectorAccumulatorV2 implements AccumulatorV2<MyVector, MyVector> {
      
        private MyVector myVector = MyVector.createZeroVector();
      
        public void reset() {
          myVector.reset();
        }
      
        public void add(MyVector v) {
          myVector.add(v);
        }
        ...
      }
      
      // Then, create an Accumulator of this type:
      VectorAccumulatorV2 myVectorAcc = new VectorAccumulatorV2();
      // Then, register it into spark context:
      jsc.sc().register(myVectorAcc, "MyVectorAcc1");

      注意,在开发者定义自己的 AccumulatorV2 类型时, resulting type(返回值类型)可能与添加的元素的类型不一致。

五、调度流程

5.1 宽窄依赖

  

窄依赖:

父RDD和子RDD partition之间的关系是一对一的。或者父RDD一个partition只对应一个子RDD的partition情况下的父RDD和子RDD partition关系是多对一的。不会有shuffle的产生。父RDD一个分区去到子RDD的一个分区

宽依赖:

父RDD与子RDD partition之间的关系是一对多会有shuffle的产生。父RDD的一个分区的数据去到子RDD的不同分区里面。

(其实区分宽窄依赖主要就是看父RDD的一个Partition的流向,要是流向一个的话就是窄依赖,流向多个的话就是宽依赖。)

 5.2 stage切分

  

  Spark任务会根据RDD之间的依赖关系,形成一个DAG有向无环图,DAG会提交给DAGScheduler,DAGScheduler会把DAG划分相互依赖的多个stage,划分stage的依据就是RDD之间的宽窄依赖。遇到宽依赖就划分stage,每个stage包含一个或多个task任务。然后将这些task以taskSet的形式提交给TaskScheduler运行stage是由一组并行的task组成。

  切割规则:从后往前遇到宽依赖就切割stage。

  一个stage内的窄依赖是pipeline管道计算模式,pipeline只是一种计算思想,模式。

  • Spark的pipeLine的计算模式,相当于执行了一个高阶函数f3(f2(f1(textFile))) !+!+!=3 也就是来一条数据然后计算一条数据,把所有的逻辑走完,然后落地,准确的说一个task处理遗传分区的数据 因为跨过了不同的逻辑的分区。而MapReduce是 1+1=2,2+1=3的模式,也就是计算完落地,然后在计算,然后再落地到磁盘或内存,最后数据是落在计算节点上,按reduce的hash分区落地。所以这也是比Mapreduce快的原因,完全基于内存计算。
  • 管道中的数据何时落地:shuffle write的时候,对RDD进行持久化的时候。
  • Stage的task并行度是由stage的最后一个RDD的分区数来决定的 。一般来说,一个partiotion对应一个task,但最后reduce的时候可以手动改变reduce的个数,也就是分区数,即改变了并行度。例如reduceByKey(XXX,3),GroupByKey(4),union由的分区数由前面的相加。
  • 如何提高stage的并行度:reduceBykey(xxx,numpartiotion),join(xxx,numpartiotion)

5.3 执行流程

   

  Driver运行在客户端:

    • 客户端启动后直接运行用户程序,启动Driver相关的工作,初始化SparkContext时候最重要的就是构造一个DAGScheduler和TaskScheduler。
    • DAGScheduler首先创建一个finalStage,然后递归方式倒着切割Stage
    • 客户端的Driver向Master注册。
    • Master还会让Worker启动Exeuctor。Worker创建一个ExecutorRunner线程,ExecutorRunner会启动ExecutorBackend进程。
    • ExecutorBackend启动后会向Driver的SchedulerBackend注册。
    • 每个Stage包含的Task通过TaskScheduler分配给Executor执行。
    • 所有stage都完成后作业结束。

    (如果Driver运行在Worker上,客户端提交作业给Master,Master让一个Worker启动Driver,即SchedulerBackend。)

  Spark on Yarn:

  

 5.4 任务调度

  

 

posted on 2018-11-16 16:45  ErBing  阅读(362)  评论(0编辑  收藏  举报