从0开始学习spark（4）Spark Rdd常用算子和RDD必备知识！！！

每日福利来一个，话不多说，我们直接开始今天的spark的学习，之前我们学习了Spark的基础原理，和概念，然后学习的spark的第一个程序wordcount，并学习了spark的作业提交运行方法和模式，下面我们开始学习spark RDD ，并熟悉使用RDD里面的常用的算子。
没有看前面的同学可以回顾一下：
3.spark core 核心知识
2.spark 之 wordcount入门
1.spark 入门讲解

1. RDD

1.1 什么是RDD

RDD（Resilient Distributed Dataset）叫做分布式数据集，是 Spark 中最基本的数据抽象，它 代表一个不可变、可分区、里面的元素可并行计算的集合。RDD 具有数据流模型的特点： 自动容错、位置感知性调度和可伸缩性。RDD 允许用户在执行多个查询时显式地将工作集缓 存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。

我们可以从三个方面来理解这个RDD：

**1.数据集 DataSet：**顾名思义，RDD是数据集合的抽象表现，是复杂物理介质质上存在数据的一 种逻辑视图。从外部来看，RDD 的确可以被看待成经过封装，带扩展特性（如容错性）的数据集合。

2、分布式 Distributed：RDD 的数据可能在物理上存储在多个节点的磁盘或内存中，也就是 所谓的多级存储。

3、弹性 Resilient：虽然 RDD 内部存储的数据是只读的，但是，我们可以去修改（例如通 过 repartition 转换操作）并行计算计算单元的划分结构，也就是分区的数量。

我们可以将 RDD 理解为一个大的集合，将所有数据都加载到内存中，方便进行多次重用。第一， 它是分布式的，可以分布在多台机器上，进行计算。第二，它是弹性的，我认为它的弹性体 现在每个 RDD 都可以保存内存中，如果某个阶段的 RDD 丢失，不需要从头计算，只需要提 取上一个 RDD，再做相应的计算就可以了

1.2 RDD 的属性

1、A list of partitions：一组分片（Partition），即数据集的基本组成单位
1、一个分区通常与一个计算任务关联，分区的个数决定了并行的粒度；
2、分区的个数可以在创建 RDD 的时候进行设置。如果没有设置，默认情况下由节点的 cores 个数决定；
3、每个 Partition 最终会被逻辑映射为 BlockManager 中的一个 Block，而这个 Block 会被下一 个 Task（ShuffleMapTask/ResultTask）使用进行计算

2、A function for computing each split：
一个计算每个分区的函数，也就是算子 分区处理函数-compute
1、每个 RDD 都会实现 compute，用于对分区进行计算；
2、compute 函数会对迭代器进行复合，不需要保存每次计算结果；
3、该方法负责接收 parent RDDs 或者 data block 流入的 records 并进行计算，然后输出加工 后的 records。

3、A list of dependencies on other RDDs：
RDD 之间的依赖关系：宽依赖和窄依赖 RDD 的每次转换都会生成一个新的 RDD，所以 RDD 之间就会形成类似于流水线一样的前后 依赖关系。在部分分区数据丢失时，Spark 可以通过这个依赖关系重新计算丢失的分区数据， 而不是对 RDD 的所有分区进行重新计算。
RDDx 依赖的 parent RDD 的个数由不同的转换操作决定，例如二元转换操作 x = a.join(b)，RDD x 就会同时依赖于 RDD a 和 RDD b。而具体的依赖关系可以细分为完全依赖和部分依赖，详 细说明如下：
1、完全依赖：一个子 RDD 中的分区可以依赖于父 RDD 分区中一个或多个完整分区。 例如，map 操作产生的子 RDD 分区与父 RDD 分区之间是一对一的关系；对于 cartesian 操作
产生的子 RDD 分区与父 RDD 分区之间是多对多的关系。

2、部分依赖：父 RDD 的一个 partition 中的部分数据与 RDD x 的一个 partition 相关，而另一 部分数据与 RDD x 中的另一个 partition 有关。

4、Optionally, a Partitioner for key-value RDDs (to say that the RDD is hash-partitioned)： 一个 Partitioner，即 RDD 的分片函数。 当前 Spark 中实现了两种类型的分片函数，一个是基于哈希的 HashPartitioner，另外一个是 基于范围的 RangePartitioner。只有对于于 key-value 的 RDD，才会有 Partitioner，非 key-value的 RDD 的 Parititioner 的值是 None。Partitioner 函数不但决定了 RDD 本身的分片数量，也决 定了 parent RDD Shuffle 输出时的分片数量。
1、只有键值对 RDD，才会有 Partitioner。其他非键值对的 RDD 的 Partitioner 为 None； 2、它定义了键值对 RDD 中的元素如何被键分区，能够将每个键映射到对应的分区 ID，从 0 到”numPartitions- 1”上；
3、Partitioner 不但决定了 RDD 本身的分区个数，也决定了 parent RDD shuffle 输出的分区个 数。
4、在分区器的选择上，默认情况下，如果有一组 RDDs（父 RDD）已经有了 Partitioner，则 从中选择一个分区数较大的 Partitioner；否则，使用默认的 HashPartitioner。
5、对于 HashPartitioner 分区数的设置，如果配置了 spark.default.parallelism 属性，则将分区 数设置为此值，否则，将分区数设置为上游 RDDs 中最大分区数。

5、Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)：一个列表，存储存取每个 Partition 的优先位置（preferred location）。
1、对于一个 HDFS 文件来说，这个列表保存的就是每个 Partition 所在的块的位置。
2、按照”移动数据不如移动计算”的理念，Spark 在进行任务调度的时候，会尽可能地将计算 任务分配到其所要处理数据块的存储位置。
3、每个子 RDDgetPreferredLocations 的实现中，都会优先选择父 RDD 中对应分区的 preferedLocation，其次才选择自己设置的优先位置

2. 创建 RDD

上面我们学习了什么是RDD，然后我们下面开始学习如何创建一个RDD数据集：
创建 RDD 主要有两种方式：官网解释 There are two ways to create RDDs: parallelizing an existing collection in your driver program, or referencing a dataset in an external storage system, such as a shared filesystem, HDFS, HBase, or any data source offering a Hadoop InputFormat.
1、由一个已经存在的 Scala 数据集合创建

val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8)) 
val rdd = sc.makeRDD(Array(1,2,3,4,5,6,7,8)) 

2、由外部存储系统的数据集创建，包括本地的文件系统，还有所有 Hadoop 支持的数据集， 比如 HDFS、Cassandra、HBase 等

 val rdd = sc.textFile("hdfs://myha01/spark/wc/input/words.txt") 

3、扩展
从 HBase 当中读取
从 ElasticSearch 中读取

3. RDD常见的算子介绍

RDD 的编程 API
RDD编程官网：http://spark.apache.org/docs/latest/rdd-programming-guide.html#resilient-distributed-datasets-rdds
首先我们学习算子的时候分为两类：

3.1 Transformation 类算子：

RDD 中的所有转换（Transformation）都是延迟加载的，也就是说，它们并不会直接计算结 果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当 发生一个要求返回结果给 Driver 的动作时，这些转换才会真正运行。这种设计让 Spark 更加 有效率地运行
官网：http://spark.apache.org/docs/latest/rdd-programming-guide.html#transformations
概念：字面意思就是进行转换，将rdd由一个形态，转化成另外一个形态，比如rdd1的类型为RDD[String]—>RDD[(String, Int)]
注意：transformation的操作，是懒加载的

转换	含义
map(func)	返回一个新的RDD，该 RDD由每一个输入元素经过func 函数转换后组成
filter(func)	返回一个新的 RDD，该 RDD 由经过 func 函数计算后返 回值为 true 的输入元素组成
flatMap(func)	类似于 map，但是每一个输入元素可以被映射为 0 或 多个输出元素（所以 func 应该返回一个序列，而不是 单一元素
mapPartitions(func)	类似于 map，但独立地在 RDD 的每一个分片上运行， 因此在类型为 T 的 RDD 上运行时，func 的函数类型必 须是 Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func)	类似于 mapPartitions，但 func 带有一个整数参数表示 分片的索引值，因此在类型为 T 的 RDD 上运行时，func 的函数类型必须是(Int, Interator[T]) => Iterator[U]
sample(withReplacement, fraction, seed)	根据 fraction 指定的比例对数据进行采样，可以选择是 否使用随机数进行替换，seed 用于指定随机数生成器 种子 union(otherDataset) 对源 RDD 和参数 RDD 求并集后返回一个新的 RDD intersection(otherDataset) 对源 RDD 和参数 RDD 求交集后返回一个新的 RDD distinct([numTasks])) 对源 RDD 进行去重后返回一个新的 RDD
groupByKey([numTasks])	在一个(K,V)的 RDD 上调用，返回一个(K, Iterator[V])的 RDD
reduceByKey(func, [numTasks])	在一个(K,V)对的数据集上使用，返回一个(K,V)对的数据 集，key 相同的值，都被使用指定的 reduce 函数聚合 到一起。和 groupByKey 类似，任务的个数是可以通过 第二个可选参数来配置的。
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])	先按分区聚合再总的聚合，每次要跟初始值交流 例如：aggregateByKey(0)(+,+) 对 K/V 的 RDD 进行 操作
sortByKey([ascending], [numTasks])	在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口，返回一个按照 key 进行排序的(K,V)的 RDD
sortBy(func,[ascending], [numTasks])	与 sortByKey 类似，但是更灵活 第一个参数是根据什么排序 第二个是怎么排序，true 正序，false 倒序 第三个排序后分区数，默认与原 RDD 一样
join(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素对在一起的(K,(V,W))的 RDD，相当于内 连接（求交集）
coGroup(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的 RDD 上调用，返回一个 (K,(Iterable,Iterable))类型的 RDD
cartesian(otherDataset)	笛卡尔积
pipe(command, [envVars])	调用外部排序
coalesce(numPartitions)	重新分区，第一个参数是分区数，第二个参数是否 shuffle 默认 false，少分区变多分区 true，多分区变少 分区 false repartition(numPartitions) 重新分区，必须 shuffle，参数是要分多少区，少变多 repartitionAndSortWithinPartitions( partitioner) 重新分区+排序，比先分区再排序效率高，对K/V 的RDD 进行操作
foldByKey(zeroValue)(seqOp)	该函数用于 K/V 做折叠，合并处理，与 aggregate 类似 第一个括号的参数应用于每个 V 值，第二括号函数是 聚合例如：+
combineByKey	合并相同的 key 的值 rdd1.combineByKey(x => x, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
partitionBy(partitioner)	对 RDD 进行分区，partitioner 是分区器 例如 new HashPartition(2)
cache 与 persist	RDD 缓存，可以避免重复计算从而减少时间，区别： cache 内部调用了 persist 算子，cache 默认就一个缓存 级别 MEMORY-ONLY ，而 persist 则可以选择缓存级别
subtract(rdd)	返回前 rdd 元素不在后 rdd 的 rdd
leftOuterJoin	leftOuterJoin 类似于 SQL 中的左外关联 left outer join， 返回结果以前面的 RDD 为主，关联不上的记录为空。 只能用于两个 RDD之间的关联，如果要多个 RDD关联， 多关联几次即可。
rightOuterJoin	rightOuterJoin 类似于 SQL 中的有外关联 right outer join，返回结果以参数中的 RDD 为主，关联不上的记录 为空。只能用于两个 RDD 之间的关联，如果要多个 RDD 关联，多关联几次即可
subtractByKey	substractByKey 和基本转换操作中的 subtract 类似只不 过这里是针对 K 的，返回在主 RDD 中出现，并且不在 otherRDD 中出现的元素
总结：	Transformation 返回值还是一个 RDD。它使用了链式调用的设计模式，对一个 RDD 进行计 算后，变换成另外一个 RDD，然后这个 RDD 又可以进行另外一次转换。这个过程是分布式 的
–	–

3.2 action 类算子：

官网：http://spark.apache.org/docs/latest/rdd-programming-guide.html#actions
概念：字面意思就是执行，action的操作目的就是用来执行一个job作业的
注意：action操作是spark作业运行的动因

Action 算子	算子含义
reduce(func)	通过 func 函数聚集 RDD 中的所有元素，这个功能必须是可交 换且可并联的
reduceByKeyLocally	def reduceByKeyLocally(func: (V, V) => V): Map[K, V] 该函数将RDD[K,V]中每个K对应的V值根据映射函数来运算， 运算结果映射到一个 Map[K,V]中，而不是 RDD[K,V]
collect()	在驱动程序中，以数组的形式返回数据集的所有元素
count()	返回 RDD 的元素个数
first()	返回 RDD 的第一个元素（类似于 take(1)）
take(n)	返回一个由数据集的前 n 个元素组成的数组
takeSample(withReplacement ,num, [seed])	返回一个数组，该数组由从数据集中随机采样的 num 个元素 组成，可以选择是否用随机数替换不足的部分，seed 用于指 定随机数生成器种子
top	top 函数用于从 RDD 中，按照默认（降序）或者指定的排序 规则，返回前 num 个元素
takeOrdered(n, [ordering])	takeOrdered 和 top 类似，只不过以和 top 相反的顺序返回元 素
countByKey()	针对(K,V)类型的 RDD，返回一个(K,Int)的 map，表示每一个 key 对应的元素个数 foreach(func) 在数据集的每一个元素上，运行函数 func 进行更新。
foreachPartition	def foreachPartition(f: Iterator[T] => Unit): Unit 遍历每个 Partition
fold	def fold(zeroValue: T)(op: (T, T) => T): T fold 是 aggregate 的简化，将 aggregate 中的 seqOp 和 combOp 使用同一个函数 op
aggregate	def aggregate[U](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U)(implicit arg0: ClassTag[U]): U aggregate 用户聚合 RDD 中的元素，先使用 seqOp 将 RDD 中 每个分区中的 T 类型元素聚合成 U 类型，再使用 combOp 将 之前每个分区聚合后的U类型聚合成U类型，特别注意seqOp 和 combOp 都会使用 zeroValue 的值，zeroValue 的类型为 U
lookup	针对 key-value 类型的 RDD 进行查找
saveAsTextFile(path)	将数据集的元素以 textfile 的形式保存到 HDFS 文件系统或者 其他支持的文件系统，对于每个元素，Spark 将会调用 toString 方法，将它装换为文件中的文本
saveAsSequenceFile(path)	将数据集中的元素以 Hadoop sequencefile 的格式保存到指定 的目录下，可以使 HDFS 或者其他 Hadoop 支持的文件系统
saveAsObjectFile(path)	saveAsObjectFile 用于将 RDD 中的元素序列化成对象，存储到 文件中。对于 HDFS，默认采用 SequenceFile 保存
总结：	Action 返回值不是一个 RDD。它要么是一个 Scala 的普通集合，要么是一个值，要么是空， 最终或返回到 Driver 程序，或把 RDD 写入到文件系统中
–	–

3.3 WordCount 中的 RDD

那么问题来了，请问在下面这一句标准的 wordcount 中到底产生了几个 RDD 呢？？？ sc.textFile(“hdfs://myha01/wc/input/words.txt”).flatMap(.split("")).map((,1))
.reduceByKey(+).collect

4. RDD的依赖关系

RDD 和它依赖的父 RDD（s）的关系有两种不同的类型，即窄依赖（narrow dependency）和 宽依赖（wide dependency

4.1 窄依赖和宽依赖对比

窄依赖指的是每一个父 RDD 的 Partition 最多被子 RDD 的一个 Partition 使用
总结：窄依赖我们形象的比喻为独生子女，窄依赖的函数有：map, filter, union, join(父 RDD 是 hash-partitioned ), mapPartitions, mapValues

宽依赖指的是多个子 RDD 的 Partition 会依赖同一个父 RDD 的 Partition
总结：窄依赖我们形象的比喻为超生，宽依赖的函数有：groupByKey、partitionBy、reduceByKey、 sortByKey、join(父 RDD 不是 hash-partitioned )

4.2、窄依赖和宽依赖总结

在这里我们是从父 RDD 的 partition 被使用的个数来定义窄依赖和宽依赖，因此可以用一句 话概括下：如果父 RDD 的一个 Partition 被子 RDD 的一个 Partition 所使用就是窄依赖，否则 的话就是宽依赖。因为是确定的 partition 数量的依赖关系，所以 RDD 之间的依赖关系就是 窄依赖；由此我们可以得出一个推论：即窄依赖不仅包含一对一的窄依赖，还包含一对固定 个数的窄依赖。

一对固定个数的窄依赖的理解：即子 RDD 的 partition 对父 RDD 依赖的 Partition 的数量不会 随着 RDD 数据规模的改变而改变；换句话说，无论是有 100T 的数据量还是 1P 的数据量， 在窄依赖中，子 RDD 所依赖的父 RDD 的 partition 的个数是确定的，而宽依赖是 shuffle 级别 的，数据量越大，那么子 RDD 所依赖的父 RDD 的个数就越多，从而子 RDD 所依赖的父 RDD 的 partition 的个数也会变得越来越多。

4.3、Lineage

RDD 只支持粗粒度转换，即在大量记录上执行的单个操作。将创建 RDD 的一系列 Lineage（即 血统）记录下来，以便恢复丢失的分区。RDD 的 Lineage 会记录 RDD 的元数据信息和转换行 为，当该 RDD 的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据 分区。

5. DAG 生成

DAG(Directed Acyclic Graph)叫做有向无环图，原始的RDD通过一系列的转换就就形成了DAG， 根据 RDD 之间的依赖关系的不同将 DAG 划分成不同的 Stage，对于窄依赖，partition 的转换 处理在 Stage 中完成计算。对于宽依赖，由于有 Shuffle 的存在，只能在 parent RDD 处理完 成后，才能开始接下来的计算，因此宽依赖是划分 Stage 的依据。

在 spark 中，会根据 RDD 之间的依赖关系将 DAG 图（有向无环图）划分为不同的阶段，对 于窄依赖，由于 partition 依赖关系的确定性，partition 的转换处理就可以在同一个线程里完 成，窄依赖就被 spark 划分到同一个 stage 中，而对于宽依赖，只能等父 RDD shuffle 处理完 成后，下一个 stage 才能开始接下来的计算。

因此 spark 划分 stage 的整体思路是：从后往前推，遇到宽依赖就断开，划分为一个 stage； 遇到窄依赖就将这个 RDD 加入该 stage 中。因此在上图中 RDD C，RDD D，RDD E，RDD F 被 构建在一个 stage 中，RDD A 被构建在一个单独的 Stage 中，而 RDD B 和 RDD G 又被构建在 同一个 stage 中。

在 spark 中，Task 的类型分为 2 种：ShuffleMapTask 和 ResultTask

简单来说，DAG 的最后一个阶段会为每个结果的 partition 生成一个 ResultTask，即每个 Stage 里面的 Task 的数量是由该 Stage 中最后一个 RDD 的 Partition 的数量所决定的！而其余所有 阶段都会生成 ShuffleMapTask；之所以称之为 ShuffleMapTask 是因为它需要将自己的计算结 果通过 shuffle 到下一个 stage 中；也就是说上图中的 stage1 和 stage2 相当于 MapReduce 中 的 Mapper，而 ResultTask 所代表的 stage3 就相当于 MapReduce 中的 reducer。

在之前动手操作了一个 WordCount 程序，因此可知，Hadoop 中 MapReduce 操作中的 Mapper 和 Reducer 在 spark 中的基本等量算子是 map 和 reduceByKey；不过区别在于：Hadoop 中的 MapReduce 天生就是排序的；而 reduceByKey 只是根据 Key 进行 reduce，但 spark 除了这两 个算子还有其他的算子；因此从这个意义上来说，Spark 比 Hadoop 的计算算子更为丰富。

6. RDD 缓存

Spark 速度非常快的原因之一，就是在不同操作中可以在内存中持久化或缓存个数据集。当 持久化某个 RDD 后，每一个节点都将把计算的分片结果保存在内存中，并在对此 RDD 或衍 生出的 RDD 进行的其他动作中重用。这使得后续的动作变得更加迅速。RDD 相关的持久化 和缓存，是 Spark 最重要的特征之一。可以说，缓存是 Spark 构建迭代式算法和快速交互式 查询的关键。

6.1 RDD 的缓存方式

RDD 通过 persist 方法或 cache 方法可以将前面的计算结果缓存，但是并不是这两个方法被 调用时立即缓存，而是触发后面的 action 时，该 RDD 将会被缓存在计算节点的内存中，并 供后面重用。

通过查看源码发现 cache 最终也是调用了 persist 方法，默认的存储级别都是仅在内存存储一 份，Spark 的存储级别还有好多种，存储级别在 object StorageLevel 中定义的。



缓存有可能丢失，或者存储存储于内存的数据由于内存不足而被删除，RDD 的缓存容错机制 保证了即使缓存丢失也能保证计算的正确执行。通过基于 RDD 的一系列转换，丢失的数据 会被重算，由于 RDD 的各个 Partition 是相对独立的，因此只需要计算丢失的部分即可，并 不需要重算全部 Partition。

下次我们还要来学习哟！！！
记得点赞加关注！！！ 不迷路 ！！！
人活着真累：上车得排队，爱你又受罪，吃饭没香味，喝酒容易醉，挣钱得交税！