Spark(二) -- 计算模型（RDD）

最新推荐文章于 2022-05-10 17:20:37 发布

众里寻她千百回

最新推荐文章于 2022-05-10 17:20:37 发布

阅读量405

点赞数

分类专栏： Spark 文章标签： spark 大数据 RDD Transformation Action

本文链接：https://blog.csdn.net/JeremyIverson/article/details/104685173

版权

Spark 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1. 弹性分布式数据集RDD

1.1. RDD概述

1.1.1. 什么是RDD

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

1.1.2. RDD的属性

在这里插入图片描述

一组分片（Partition），即数据集的基本组成单位。对于RDD来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。
一个计算每个分区的函数。Spark中RDD的计算是以分片为单位的，每个RDD都会实现compute函数以达到这个目的。compute函数会对迭代器进行复合，不需要保存每次计算的结果。
RDD之间的依赖关系。RDD的每次转换都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算。
一个Partitioner，即RDD的分片函数。当前Spark中实现了两种类型的分片函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。只有对于于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。
一个列表，存储存取每个Partition的优先位置（preferred location）。对于一个HDFS文件来说，这个列表保存的就是每个Partition所在的块的位置。按照“移动数据不如移动计算”的理念，Spark在进行任务调度的时候，会尽可能地将计算任务分配到其所要处理数据块的存储位置。

1.2. 创建RDD

由一个已经存在的Scala集合创建。

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

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

val rdd2 = sc.textFile("hdfs://hadoop01:9000/words.txt")

1.3. RDD编程API

1.3.1. Transformation

RDD中的所有转换都是延迟加载的，也就是说，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这种设计让Spark更加有效率地运行
$\color{red}{常用的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)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
aggregateByKey(num)(func1, func2)	aggregate(num)(func1,func2):聚合,第一个参数为聚合的初始值，第二个func为各个partition执行的计算操作，func2为上一步即各个partition计算结果的需要进行的操作
sortByKey([ascending], [numTasks])	在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])	与sortByKey类似，但是更灵活
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)	笛卡尔积

1.3.2. Action

触发执行的Spark算子

$\color{red}{常用的Action算子}$

动作	含义
reduce(func)	通过func函数聚集RDD中的所有元素，这个功能必须是课交换且可并联的
collect()	在驱动程序中，以数组的形式返回数据集的所有元素
count()	返回RDD的元素个数
first()	返回RDD的第一个元素（类似于take(1)）
take(n)	返回一个由数据集的前n个元素组成的数组
takeSample(withReplacement,num, [seed])	返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n, [ordering])
saveAsTextFile(path)	将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)	将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)
countByKey()	针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)	在数据集的每一个元素上，运行函数func进行更新。

$\color{red}{RDD使用举例}$

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

val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8),2)
def func1(index: Int, iter: Iterator[(Int)]) : Iterator[String] = {
       iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
     }
rdd1.mapPartitionsWithIndex(func1).collect
//结果如下：
res2: Array[String] = Array([partID:0, val: 1], [partID:0, val: 2], [partID:0, val: 3], [partID:0, val: 4], [partID:1, val: 5], [partID:1, val: 6], [partID:1, val: 7], [partID:1, val: 8])

aggregate(num)(func1,func2):聚合,第一个参数为聚合的初始值，第二个func为各个partition执行的计算操作，func2为上一步即各个partition计算结果的需要进行的操作

//求rdd1的中各个数组元素之和
scala> rdd1.aggregate(0)(_+_,_+_)
res3: Int = 36

//求rdd1中的各个partition中的最大值之和
scala> rdd1.aggregate(0)(math.max(_,_),_+_)
res4: Int = 12

// res2: Array[String] = Array([partID:0, val: 1], [partID:0, val: 2], [partID:0, val: 3], [partID:0, val: 4], [partID:1, val: 5], [partID:1, val: 6], [partID:1, val: 7], [partID:1, val: 8])
//初始值为5，partID为0分区最大变为5，partID为1分区最大值不变仍为8， 故结果为5+5+8
scala> rdd1.aggregate(5)(math.max(_,_),_+_)
res5: Int = 18


scala> val rdd2 = sc.parallelize(List("a","b","c","d","e","f"),2)
rdd2: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[2] at parallelize at <console>:27

scala> rdd2.aggregate("")(_+_,_+_)
res9: String = abcdef

scala> rdd2.aggregate("|")(_+_,_+_)
res10: String = ||abc|def

//两个partition的上的任务并行运行，partition0和partition1都有可能先结束
scala> val rdd3 = sc.parallelize(List("12","23","345","4567"),2)
rdd3: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[4] at parallelize at <console>:27

scala> rdd3.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
res11: String = 42

scala> rdd3.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
res12: String = 24


scala> val rdd4 = sc.parallelize(List("12","23","345",""),2)
rdd4: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[5] at parallelize at <console>:27

scala> rdd4.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res13: String = 10

scala> rdd4.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res14: String = 01


scala> val rdd5 = sc.parallelize(List("12","23","","345"),2)
rdd5: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[6] at parallelize at <console>:27

scala> rdd5.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
res16: String = 11

aggregateByKey：按key进行聚合，传入参数和aggregate相同

scala> val pairRDD = sc.parallelize(List( ("cat",2), ("cat", 5), ("mouse", 4),("cat", 12), ("dog", 12), ("mouse", 2)), 2)
pairRDD: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at <console>:27

scala> def func2(index: Int, iter: Iterator[(String, Int)]) : Iterator[String] = {
     |   iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
     | }
func2: (index: Int, iter: Iterator[(String, Int)])Iterator[String]

scala> pairRDD.mapPartitionsWithIndex(func2).collect
[Stage 0:>                                                          (0 + 0) / 2]19/12/14 11:06:38 WARN SizeEstimator: Failed to check whether UseCompressedOops is set; assuming yes
res0: Array[String] = Array([partID:0, val: (cat,2)], [partID:0, val: (cat,5)], [partID:0, val: (mouse,4)]、, [partID:1, val: (cat,12)], [partID:1, val: (dog,12)], [partID:1, val: (mouse,2)])
//两个动物圈中分别有如下动物
// [partID:0, val: (cat,2)], [partID:0, val: (cat,5)], [partID:0, val: (mouse,4)]
//[partID:1, val: (cat,12)], [partID:1, val: (dog,12)], [partID:1, val: (mouse,2)]

//计算每种动物的数量
scala> pairRDD.aggregateByKey(0)(_ + _, _ + _).collect
res1: Array[(String, Int)] = Array((dog,12), (cat,19), (mouse,6))

//先计算每种圈中数量最多的动物，再将各个圈中数量最多的动物数量之和
scala> pairRDD.aggregateByKey(0)(math.max(_, _), _ + _).collect
res2: Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,6))

combineByKey(func1,func2,func3)：聚合,func1为各个分区按key进行分组，对组内第一个value进行的操作；func2为组内其他value和func1处理后的结果进行聚合的操作，func3为对各个分区func2处理结果进行聚合的处理操作

//动物种类集合
scala> val rdd4 = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
rdd4: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[19] at parallelize at <console>:27

//动物对应的数量之和，需求：将数量相同的动物放到同一个List中
scala> val rdd5 = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
rdd5: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[20] at parallelize at <console>:27

scala> val rdd6 = rdd5.zip(rdd4)
rdd6: org.apache.spark.rdd.RDD[(Int, String)] = ZippedPartitionsRDD2[21] at zip at <console>:31

scala> rdd6.collect
res6: Array[(Int, String)] = Array((1,dog), (1,cat), (2,gnu), (2,salmon), (2,rabbit), (1,turkey), (2,wolf), (2,bear), (2,bee))

scala> rdd6.combineByKey(List(_),(x:List[String],y:String) => x :+ y ,(a:List[String],b:List[String]) => a ++ b )
res9: org.apache.spark.rdd.RDD[(Int, List[String])] = ShuffledRDD[24] at combineByKey at <console>:34

scala> res9.collect
res10: Array[(Int, List[String])] = Array((1,List(turkey, dog, cat)), (2,List(salmon, rabbit, gnu, wolf, bear, bee)))

repartition 、coalesce：对RDD重新进行分区

scala> val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[25] at parallelize at <console>:27

scala> val func = (index: Int, iter: Iterator[(Int)]) => {
     |   iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
     | }
func: (Int, Iterator[Int]) => Iterator[String] = <function2>

scala> rdd1.mapPartitionsWithIndex(func).collect
res11: Array[String] = Array([partID:0, val: 1], [partID:0, val: 2], [partID:0, val: 3], [partID:0, val: 4], [partID:1, val: 5], [partID:1, val: 6], [partID:1, val: 7], [partID:1, val: 8], [p

scala> val rdd2 = rdd1.repartition
                                                                                    def repartition(numPartitions: Int)(implicit ord: scala.math.Ordering[T]): RDD[T]   

scala> val rdd2 = rdd1.repartition
                                                                                    def repartition(numPartitions: Int)(implicit ord: scala.math.Ordering[T]): RDD[T]   

scala> val rdd2 = rdd1.repartition(3)
rdd2: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[30] at repartition at <console>:29

scala> rdd2.partitions.length
res12: Int = 3

scala> rdd2.mapPartitionsWithIndex(func).collect
res13: Array[String] = Array([partID:0, val: 3], [partID:0, val: 7], [partID:1, val: 5], [partID:1, val: 8], [partID:1, val: 1], [partID:1, val: 4], [partID:2, val: 6], [partID:2, val: 9], [partID:2, val: 2])

// coalesce 如果已经进行了分区，不加true参数，默认将不再分区
scala> val rdd3 = rdd1.coalesce(3)
rdd3: org.apache.spark.rdd.RDD[Int] = CoalescedRDD[32] at coalesce at <console>:29

scala> rdd3.partitions.length
res14: Int = 2

scala> val rdd3 = rdd1.coalesce(3,true)
rdd3: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[36] at coalesce at <console>:29

scala> rdd3.partitions.length
res15: Int = 3

scala> rdd3.mapPartitionsWithIndex(func).collect
res16: Array[String] = Array([partID:0, val: 3], [partID:0, val: 7], [partID:1, val: 5], [partID:1, val: 8], [partID:1, val: 1], [partID:1, val: 4], [partID:2, val: 2], [partID:2, val: 6], [partID:2, val: 9])

collectAsMap : 转化成Map

scala> val rdd = sc.parallelize(List(("a",1),("b",2)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at <console>:27

scala> rdd.collectAsMap
[Stage 0:>                                                          (0 + 0) / 2]19/12/14 16:33:46 WARN SizeEstimator: Failed to check whether UseCompressedOops is set; assuming yes
res0: scala.collection.Map[String,Int] = Map(b -> 2, a -> 1)

countByKey

scala> val rdd1 = sc.parallelize(List(("a", 1), ("b", 2), ("b", 2), ("c", 2), ("c", 1)))
rdd1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[1] at parallelize at <console>:27

scala> rdd1.countByKey
res2: scala.collection.Map[String,Long] = Map(b -> 2, a -> 1, c -> 2)

//把List中的每个元素当成一个value
scala> rdd1.countByValue
res3: scala.collection.Map[(String, Int),Long] = Map((b,2) -> 2, (c,2) -> 1, (a,1) -> 1, (c,1) -> 1)

filterByRange先排序再根据范围过滤，[“b”,“d”]:"b"和"d"都包含

scala> val rdd1 = sc.parallelize(List(("e", 5), ("c", 3), ("d", 4), ("c", 2), ("a", 1),("b",6)))
rdd1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[9] at parallelize at <console>:27

scala> val rdd2 = rdd1.filterByRange("b", "d")
rdd2: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[10] at filterByRange at <console>:29

scala> rdd2.collect
res5: Array[(String, Int)] = Array((c,3), (d,4), (c,2), (b,6))

flatMapValues：对value进行处理然后flatmap

scala> val rdd3 = sc.parallelize(List(("a", "1 2"), ("b", "3 4")))
rdd3: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[11] at parallelize at <console>:27

scala> val rdd4 = rdd3.flatMapValues(_.split(" "))
rdd4: org.apache.spark.rdd.RDD[(String, String)] = MapPartitionsRDD[12] at flatMapValues at <console>:29

scala> rdd4.collect
res6: Array[(String, String)] = Array((a,1), (a,2), (b,3), (b,4))

foldByKey

scala> val rdd1 = sc.parallelize(List("dog", "wolf", "cat", "bear"), 2)
rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[13] at parallelize at <console>:27

scala> val rdd2 = rdd1.map(x => (x.length, x))
rdd2: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[14] at map at <console>:29

scala> rdd2.collect
res7: Array[(Int, String)] = Array((3,dog), (4,wolf), (3,cat), (4,bear))        

scala> rdd2.foldByKey("")(_+_).collect
res8: Array[(Int, String)] = Array((4,wolfbear), (3,catdog))

foreachPartition

scala> val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[16] at parallelize at <console>:27

scala> rdd1.foreachPartition(x => println(x.reduce(_ + _)))

keyBy : 以传入的参数做key

scala> val rdd1 = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[0] at parallelize at <console>:27

scala> val rdd2 = rdd1.keyBy(_.length)
rdd2: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[1] at keyBy at <console>:29

scala> rdd2.collect
19/12/14 19:26:19 WARN SizeEstimator: Failed to check whether UseCompressedOops is set; assuming yes
res0: Array[(Int, String)] = Array((3,dog), (6,salmon), (6,salmon), (3,rat), (8,elephant))


scala> val rdd2 = rdd1.keyBy(_(0))
rdd2: org.apache.spark.rdd.RDD[(Char, String)] = MapPartitionsRDD[2] at keyBy at <console>:29

scala> rdd2.collect
res1: Array[(Char, String)] = Array((d,dog), (s,salmon), (s,salmon), (r,rat), (e,elephant))

1.3.3. WordCount中的RDD

以下简单的wordcount中程序中一共形成了几个RDD？

scala> val rdd1000 = sc.textFile("hdfs://hadoop01:9000/wc").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
rdd1000: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[10] at reduceByKey at <console>:27

众里寻她千百回

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spark(二) -- 计算模型（RDD）

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

扫一扫