spark笔记

概述

重要角色

dirver(驱动器)

Spark的驱动器是执行开发程序中的main方法的进程。它负责开发人员编写的用来创建SparkContext、创建RDD，以及进行RDD的转化操作和行动操作代码的执行。如果你是用spark shell，那么当你启动Spark shell的时候，系统后台自启了一个Spark驱动器程序，就是在Spark shell中预加载的一个叫作 sc的SparkContext对象。如果驱动器程序终止，那么Spark应用也就结束了。主要负责：

1）把用户程序转为作业（JOB）

2）跟踪Executor的运行状况

3）为执行器节点调度任务

4）UI展示应用运行状况

executor(执行器)

Spark Executor是一个工作进程，负责在 Spark 作业中运行任务，任务间相互独立。Spark 应用启动时，Executor节点被同时启动，并且始终伴随着整个 Spark 应用的生命周期而存在。如果有Executor节点发生了故障或崩溃，Spark 应用也可以继续执行，会将出错节点上的任务调度到其他Executor节点上继续运行。主要负责：

1）负责运行组成 Spark 应用的任务，并将结果返回给驱动器进程；

2）通过自身的块管理器（Block Manager）为用户程序中要求缓存的RDD提供内存式存储。RDD是直接缓存在Executor进程内的，因此任务可以在运行时充分利用缓存数据加速运算。

RDD

RDD叫做弹性分布式数据集，是spark中最基本的数据（计算）抽象。在代码中是一个抽象类，它代表的是一个不可变的、可分区、里面的元素可以并行计算的集合

五个主要属性

1. 一组分区，及数据集的基本组成单位
2. 一个计算每个分区的函数
3. RDD之间的依赖关系
4. 一个partitioner，即RDD的分片函数
5. 一个列表，存储存取每个partition的优先位置（preferred location）

特点

RDD表示只读的分区的数据集，对RDD进行改动，只能通过RDD的转换操作，由一个RDD得到一个新的RDD，新的RDD包含了从其他RDD衍生所必需的信息。RDDs之间存在依赖，RDD的执行是按照血缘关系延时计算的。如果血缘关系较长，可以通过持久化RDD来切断血缘关系。

以下几点应该理解

分区

只读

依赖

缓存

CheckPoint

RDD的创建

从集合创建

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

由外部存储系统的数据集创建

val rdd2= sc.textFile(“hdfs://hadoop102:9000/RELEASE”)

RDD的转换（重点）

RDD整体上分为Value类型和Key-Value类型

value类型

map(func)

返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成

例：val mapadd = source.map(_ * 2)

mapPartitions(func)

类似于map，但独立地在RDD的每一个分片（分区）上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]。假设有N个元素，有M个分区，那么map的函数的将被调用N次,而mapPartitions被调用M次,一个函数一次处理所有分区。注意：默认分片数与你机器核数相同

rdd.mapPartitions(x=>x.map(_*2))

mapPartitionsWithIndex(func)

类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]；

val indexRdd = rdd.mapPartitionsWithIndex((index,items)=>(items.map((index,_))))

给分片加上索引值

flatMap(func)

类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

val flatMap = sourceFlat.flatMap(1 to _)

res12: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5)

一对多输出

glom

将每一个分区形成一个数组，形成新的RDD类型时RDD[Array[T]]

rdd.glom().collect()

groupBy(func)

分组，按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器。

val group = rdd.groupBy(_%2)

filter(func)

过滤。返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成。

val filter = sourceFilter.filter(_.contains(“xiao”))

sample(withReplacement, fraction, seed)

以指定的随机种子随机抽样出数量为fraction的数据，withReplacement表示是抽出的数据是否放回，true为有放回的抽样，false为无放回的抽样，seed用于指定随机数生成器种子。

var sample1 = rdd.sample(true,0.4,2)

distinct([numTasks]))

对源RDD进行去重后返回一个新的RDD。默认情况下，只有8个并行任务来操作，但是可以传入一个可选的numTasks参数改变它。

val unionRDD = distinctRdd.distinct(2)

coalesce(numPartitions)

缩减分区数，用于大数据集过滤后，提高小数据集的执行效率。

val coalesceRDD = rdd.coalesce(3)

补充：coalesceRDD.partitions.size //查看该rdd的分区数

repartition(numPartitions)

根据分区数，重新通过网络随机洗牌所有数据。

val rerdd = rdd.repartition(2)

补充：

1. coalesce重新分区，可以选择是否进行shuffle过程。由参数shuffle: Boolean = false/true决定。

2. repartition实际上是调用的coalesce，默认是进行shuffle的。

sortBy(func,[ascending], [numTasks])

使用func先对数据进行处理，按照处理后的数据比较结果排序，默认为正序。

rdd.sortBy(x => x%3).collect() //按照余数大小排序

pipe(command, [envVars])（了解）

管道，针对每个分区，都执行一个shell脚本，返回输出的RDD。

双Value类型交互

union(otherDataset)

并集。对源RDD和参数RDD求并集后返回一个新的RDD

rdd1.union(rdd2)

subtract (otherDataset)

差集。计算差的一种函数，去除两个RDD中相同的元素，不同的RDD将保留下来

intersection(otherDataset)

交集。对源RDD和参数RDD求交集后返回一个新的RDD

cartesian(otherDataset)

笛卡尔积（尽量避免使用）

zip(otherDataset)

将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同，否则会抛出异常。

Key-Value类型

partitionBy

对pairRDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区， 否则会生成ShuffleRDD，即会产生shuffle过程。

var rdd2 = rdd.partitionBy(new org.apache.spark.HashPartitioner(2))

groupByKey

groupByKey也是对每个key进行操作，但只生成一个sequence。

val group = wordPairsRDD.groupByKey()

group.map(t => (t._1, t._2.sum))//计算相同key对应值的相加结果

reduceByKey(func, [numTasks])

在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。

val reduce = rdd.reduceByKey((x,y) => x+y)

reduceByKey和groupByKey的区别:

1. reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[k,v].

2. groupByKey：按照key进行分组，直接进行shuffle。

3. 开发指导：reduceByKey比groupByKey，建议使用。但是需要注意是否会影响业务逻辑。

aggregateByKey

参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

作用：在k-v对的RDD中，按key将value进行分组合并，合并时，将每个agg.collect()，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。

• 取出每个分区相同key对应值的最大值，分区间然后相加

​ val agg = rdd.aggregateByKey(0)(math.max(,),+)

注：函数的字面义，按键聚合。现在分区内聚合，然后做combine操作，分区间聚合

foldByKey

参数：(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

作用：aggregateByKey的简化操作，seqop和combop相同

val agg = rdd.foldByKey(0)(_+_)

combineByKey[C]

参数：(createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C)

作用：对相同K，把V合并成一个集合。

参数描述：

（1）createCombiner: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey()会使用一个叫作createCombiner()的函数来创建那个键对应的累加器的初始值

（2）mergeValue: 如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并

（3）mergeCombiners: 由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果进行合并。

例：将相同key对应的值相加，同时记录该key出现的次数，放入一个二元组

val combine = input.combineByKey((_,1),(acc:(Int,Int),v)=>(acc._1+v,acc._2+1),(acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UxdZvFAz-1597649913098)(spark笔记.assets/combineByKey.png)]

sortByKey([ascending], [numTasks])

在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD

mapValues

针对于(K,V)形式的类型只对V进行操作

join(otherDataset, [numTasks])

在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD。

注意：这是对两个rdd进行操作，与之前分区内分区间操作不同

rdd.join(rdd1).collect()

cogroup(otherDataset, [numTasks])

在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD

案例：创建两个pairRDD，并将key相同的数据聚合到一个迭代器。

rdd.cogroup(rdd1).collect()

Action(行动算子)

reduce(func)

通过func函数聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据。

rdd1.reduce(_+_)

collect()

在驱动程序中，以数组的形式返回数据集的所有元素。

count()

返回RDD中元素的个数

rdd.count

first()

take(n)

返回一个由RDD的前n个元素组成的数组

takeOrdered(n)

返回该RDD排序后的前n个元素组成的数组

aggregate

参数：(zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)

作用：aggregate函数将每个分区里面的元素通过seqOp和初始值进行聚合，然后用combine函数将每个分区的结果和初始值(zeroValue)进行combine操作。这个函数最终返回的类型不需要和RDD中元素类型一致。

rdd.aggregate(0)(+,+)

old(num)(func)

折叠操作，aggregate的简化操作，seqop和combop一样。

rdd.fold(0)(_+_)

save操作

saveAsTextFile(path)、saveAsSequenceFile(path)、saveAsObjectFile(path)

countByKey()

针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

foreach(func)

在数据集的每一个元素上，运行函数func进行更新。

RDD中的函数传递

在实际开发中我们往往需要自己定义一些对于RDD的操作，那么此时需要主要的是，初始化工作是在Driver端进行的，而实际运行程序是在Executor端进行的，这就涉及到了跨进程通信，是需要序列化的。

传递一个方法

使类继承scala.Serializable即可。

class Search() extends Serializable{…}

传递一个属性

• 使类继承scala.Serializable即可。
• 将类变量query赋值给局部变量

def getMatche2(rdd: RDD[String]): RDD[String] = {

val query_ : String = this.query//将类变量赋值给局部变量

rdd.filter(x => x.contains(query_))

}

任务划分

RDD任务切分中间分为：Application、Job、Stage和Task

1）Application：初始化一个SparkContext即生成一个Application

2）Job：一个Action算子就会生成一个Job

3）Stage：根据RDD之间的依赖关系的不同将Job划分成不同的Stage，遇到一个宽依赖则划分一个Stage。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ZYe2CxD-1597649913101)(spark笔记.assets/任务划分图.png)]

4）Task：Stage是一个TaskSet，将Stage划分的结果发送到不同的Executor执行即为一个Task。

注意：Application->Job->Stage-> Task每一层都是1对n的关系。

ontains(query_))

}

任务划分

RDD任务切分中间分为：Application、Job、Stage和Task

1）Application：初始化一个SparkContext即生成一个Application

2）Job：一个Action算子就会生成一个Job

3）Stage：根据RDD之间的依赖关系的不同将Job划分成不同的Stage，遇到一个宽依赖则划分一个Stage。

[外链图片转存中…(img-7ZYe2CxD-1597649913101)]

4）Task：Stage是一个TaskSet，将Stage划分的结果发送到不同的Executor执行即为一个Task。

注意：Application->Job->Stage-> Task每一层都是1对n的关系。