spark算子集合

原创

陈小哥cw 2021-09-01 15:54:29 博主文章分类：Spark ©著作权

文章标签 数据持久化数据集 spark 依赖关系 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者陈小哥cw的原创作品，请联系作者获取转载授权，否则将追究法律责任

spark算子集合

文章目录

spark算子集合

算子：Spark中， RDD的方法就叫算子（也叫函数）如flatMap,map,reduceByKey,foreach

Spark中的算子分为三类:

Transformation转换算子 [懒执行的,需要Action算子触发才执行]

map,flatMap,reduceByKey,sortBy(java不存在这个),sortByKey,filter,sample
Action行动算子 [触发Transformation类算子执行,有一个Action算子,就有一个job(任务)]

foreach,take,first,count,collect
持久化算子

spark算子集合_依赖关系

1.Transformation算子

又叫转换算子，懒执行，需要Action算子触发执行

Transformations类算子是一类算子（函数）叫做转换算子，如map,flatMap,reduceByKey等。Transformations算子是延迟执行，也叫懒加载执行(需要Action算子触发才能执行)。

map/mapToPair

将一个RDD中的每个数据项，通过map中的函数映射变为一个新的元素。

特点：输入一条，输出一条数据。

Scala只有map,Java中有map,mapToPair

Java中map输出的不能输出kv格式,要想输出kv格式数据要是用mapToPair

mapToPair会将一个长度为N的、每个元素都是T类型的对象，转换成另一个长度为N的、每个元素都是<K2,V2>类型的对象

mapPartitions

与map类似，遍历的单位是每个partition上的数据。
一个分区一个分区的数据来处理
传入的参数是一个partition的数据
单位按分区来处理数据节省某些操作需要的时间

mapPartitionWithIndex

类似于mapPartitions,除此之外还会携带分区的索引值。可获取每个分区的索引

flatMap/flatMapToPair

先map后flat。与map类似，每个输入项可以映射为0到多个输出项。

scala只有flatMap

java有flatMap和flatMapToPair,flatMapToDouble

Java中flatMap输出的不能输出kv格式,要想输出kv格式数据要是用flatMapToPair

filter

保留符合条件的记录数，true保留，false过滤掉。

sample

随机抽样算子，根据传进去的小数按比例进行又放回或者无放回的抽样。

第一个参数：是否有放回第二个参数：抽样抽多少数据（百分比），第三个参数：种子

对RDD进行抽样，其中参数withReplacement为true时表示抽样之后还放回，可以被多次抽样，false表示不放回；fraction表示抽样比例；seed为随机数种子，比如当前时间戳

reduceByKey

将相同的Key根据相应的逻辑进行处理。

reduceByKey就是对元素为KV对的RDD中Key相同的元素的Value进行binary_function的reduce操作，因此，Key相同的多个元素的值被reduce为一个值，然后与原RDD中的Key组成一个新的KV对。

sortByKey/sortBy

作用在K,V格式的RDD上，对key进行升序或者降序排序。

join

作用在K,V格式的RDD上。根据K进行连接，对（K,V）join(K,W)返回（K,(V,W)）

必须是两个k、v格式的RDD进行join，且key必须相同
只返回相同key的
join后的分区数默认与父RDD分区数多的那一个相同。
如果join指定了分区数则按照指定的分区进行
注：不设置的话分区数默认为1.

leftOuterJoin

显示左边RDD所有的key和value，右边RDD对应不上的用optional

rightOuterJoin

显示右边RDD所有的key和value，左边RDD对应不上的用optional

fullOuterJoin

两边RDD均显示,不存在用optional，显示None

union

合并两个数据集。两个数据集的类型要一致。

返回新的RDD的分区数是合并RDD分区数的总和。
逻辑上合并，不会有实际的数据传输

intersection

取两个数据集的交集，返回新的RDD与父RDD分区多的一致

subtract

取两个数据集的差集，结果RDD的分区数与subtract前面的RDD的分区数一致。
取左边RDD中右边RDD没有的元素

distinct

去重

def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
    map(x => (x, null)).reduceByKey((x, y) => x, numPartitions).map(_._1)
  }

cogroup

将两个RDD中相同key的合在一起

当调用类型（K,V）和（K，W）的数据上时，返回一个数据集（K，（Iterable<V>,Iterable<W>）），子RDD的分区与父RDD多的一致。

zip

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

将两个RDD中的元素（KV格式/非KV格式）变成一个KV格式的RDD,**两个RDD的每个分区元素个数必须相同。

zipWithIndex

该函数将RDD中的元素和这个元素在RDD中的ID（索引号）组合成键/值对。

repartition

增加或减少分区。宽依赖的算子,默认产生shuffle。（多个分区分到一个分区不会产生shuffle）

repartition底层其实就是coalesce指定了开启shuffle,变成宽依赖

repartition()一般用于增加分区

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
    coalesce(numPartitions, shuffle = true)
}

coalesce

重分区,可以将RDD的分区增大,也可以减少,默认不产生shuffle.

coalesce常用来减少分区，第二个参数是减少分区的过程中是否产生shuffle。true为产生shuffle，false不产生shuffle。默认是false。

Coalesec()一般用于减少分区。Coalesec()方法不产生shuffle的话增加分区就不起作用，但如果指定产生shuffle的话那就是repartition()。

如果coalesce设置的分区数比原来的RDD的分区数多的话，第二个参数设置为false时不会起作用,分区情况不会变化，如果设置成true，效果和repartition一样。即repartition(numPartitions) = coalesce(numPartitions,true)

def coalesce(numPartitions: Int, shuffle: Boolean = false,
               partitionCoalescer: Option[PartitionCoalescer] = Option.empty)

groupByKey

作用在K，V格式的RDD上。根据Key进行分组,将相同key的聚合到一起。作用在（K，V），返回（K，Iterable <V>）。会产生shuffle

对每个key对应的多个value进行操作，但是只是汇总生成一个sequence，本身不能自定义函数，只能通过额外通过map(func)来实现。

2.Action算子

Action类算子也是一类算子（函数）叫做行动算子，如foreach,collect，count等。

Transformations类算子是延迟执行，Action类算子触发Transformations类算子执行。

一个application应用程序中有几个Action类算子执行，就有几个job运行。

count

返回数据集中的元素数。会在结果计算完成后回收到Driver端。

foreach

循环遍历数据集中的每个元素，运行相应的逻辑。

take

take(n)返回一个包含数据集前n个元素的集合。

first

first=take(1),返回数据集中的第一个元素。

collect

将计算结果回收到Driver端。

foreachPartition

遍历的数据是每个partition的数据。

以分区为单位进行遍历可以避免重复建立连接等

foreach以每一条数据为单位遍历

没有返回值（mapPartitions有返回RDD）

countByKey

必须作用到K,V格式的RDD上，根据Key计数相同Key的数据集元素。

   def countByKey(): Map[K, Long] = self.withScope {
       self.mapValues(_ => 1L).reduceByKey(_ + _).collect().toMap
     }

countByValue

根据数据集每个元素相同的内容来计数。返回相同内容的元素对应的条数。(不必作用在kv格式上)

countByValue()方法将整个元组看做value,不是将逗号后面的内容看做value

  def countByValue()(implicit ord: Ordering[T] = null): Map[T, Long] = withScope {
      map(value => (value, null)).countByKey()
    }

reduce

根据聚合逻辑聚合数据集中的每个元素。

reduce将RDD中元素前两个传给输入函数，产生一个新的return值，新产生的return值与RDD中下一个元素（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止。

3.持久化算子

持久化有三个算子：

Cache
Persist
checkpoint

以上算子都可以将RDD持久化，持久化的单位是partition。cache和persist都是懒执行的。必须有一个action类算子触发执行。checkpoint算子不仅能将RDD持久化到磁盘，还能切断RDD之间的依赖关系。

cache

默认将数据存于内存中,相当于指定了只是用内存存储策略的persist

默认将RDD的数据持久化到内存中。**cache是懒执行。**需要Action算子触发执行

cache和persist不需要指定目录,spark集群会默认为cache,persist创建目录

cache和persist的目录在application执行完后会清空

cache()=persist()=persist(StorageLevel.MEMORY_ONLY)

def cache(): this.type = persist()

def persist(): this.type = persist(StorageLevel.MEMORY_ONLY)//只用内存

val MEMORY_ONLY = new StorageLevel(false, true, false, true)

注意:cache和persist算子后不能立即紧跟action算子。(如:lines.cache().collect()是不行的)

var lines = sc.textFile("./data/words")
    //如果赋值给变量,后面不能紧跟action算子
    //    lines = lines.cache().foreach()
    lines = lines.cache()
    lines = lines.persist()

persist

可以手动指定持久化级别.最常用的是MEMORY_ONLY和MEMORY_AND_DISK。”_2”表示有副本数。

cache和persist不需要指定目录,spark集群会默认为cache,persist创建目录

cache和persist的目录在application执行完后会清空

持久化级别如下：

class StorageLevel private(
    private var _useDisk: Boolean,//是否使用磁盘
    private var _useMemory: Boolean,//是否使用内存
    private var _useOffHeap: Boolean,//是否使用堆外内存(一般不会使用)
    private var _deserialized: Boolean,//是否不序列化
    private var _replication: Int = 1)//副本


val NONE = new StorageLevel(false, false, false, false)
val DISK_ONLY = new StorageLevel(true, false, false, false)
val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2)
val MEMORY_ONLY = new StorageLevel(false, true, false, true)
val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false)
val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)
val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)//先往内存中放,不够了再往磁盘放,以块为单位
val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
val OFF_HEAP = new StorageLevel(true, true, true, false, 1)

常用级别:

MEMORY_ONLY
MEMORY_ONLY_SER
MEMORY_AND_DISK 先往内存中放,不够了再往磁盘(放磁盘的数据一定会序列化)放,以块为单位
MEMORY_AND_DISK_SER

尽量避免使用"_2"的级别和DISK_ONLY级别

放磁盘的数据一定会序列化

堆外内存：不归JVM管的内存就是堆外内存

Spark存储数据可以指定副本个数

checkpoint

当RDD的lineage非常长,计算逻辑复杂时,可以对某个RDD进行checkpoint,会将当前的数据持久化到指定的磁盘目录上.

checkpoint默认将RDD数据持久化到磁盘，还可以切断RDD之间的依赖关系。

可以保存数据到外部存储系统。（可以解决宕机问题，宕机时保存状态，数据执行到哪里了的问题），切断依赖关系。
checkpoint需要自己指定目录
checkpoint主要用在元数据保存上
checkpoint目录数据当application执行完之后不会被清除,不手动删除就会一直存在。

第二次再次访问同一个RDD时，就会从上次持久化的checkpoint持久化数据中获取。
checkpoint相比cache和persist多了一个功能:存储元数据.checkpoint真正用在持久化数据上用的其实并不多

checkpoint特点

可以对RDD进行checkpoint,将数据存储在外部的文件存储系统,当spark application执行完成之后,数据不会被清除.正是这个特点,我们可以使用checkpoint保存状态.在sparkstreaming中应用多

作用：

将数据持久化到磁盘
保存程序运行状态

设置了checkpoint之后，会将这个RDD向前切断RDD的依赖关系

一定要避免对RDD进行多次checkPoint。千万不要经常的对RDD进行checkpoint,因为每次checkpoint一次就会存到磁盘一次,过多存储就会和mapreduce在磁盘存储一样了,这样会让性能下降

checkpoint流程

当RDD的job执行完毕后，会从finalRDD从后往前回溯。
当回溯到某一个RDD调用了checkpoint方法，会对当前的RDD做一个标记。
回溯完成后,Spark框架会自动启动一个新的job，重新计算这个checkpoint RDD的数据，将数据持久化到HDFS的指定目录上。
下一步会向前切断RDD的依赖关系,下次如果checkpoint标记的RDD后的RDD数据丢了后,可以使用checkpoint这个目录去恢复后面的RDD的数据,不用再向前去找了,节省了时间

比如，要计算打五角星的这个RDD的数据，在这个job执行完成之后，会重新从数据的源头重新计算一遍之前的一个RDD中的数据并存放于程序中指定的外部存储目录。默认是将数据持久化到磁盘。

当下次重新计算五角星的RDD中的数据时，会直接从checkPoint的RDD中恢复数据，而不会从之前的有依赖关系的RDD中计算数据

spark算子集合_持久化_02

当最后一个RDD的action执行完时,会重启一个job,从后往前回溯,一直回溯到源头,找到那些被标记成checkpoint的RDD的数据,重新计算该数据,将该数据存放到程序中指定的外部存储目录(一般是HDFS上的某个目录),下一步会向前切断RDD的依赖关系,下次如果checkpoint标记的RDD后的RDD数据丢了后,可以基于checkpoint这个目录去恢复后面的RDD的数据

checkpoint的优化

对RDD执行checkpoint之前，最好对这个RDD先执行cache，这样新启动的job只需要将内存中的数据拷贝到HDFS上就可以，省去了重新计算这一步。

对哪个RDD设置了checkPoint就对其进行cache持久化，action类算子触发cache持久化将数据存入内存中。当新建的job进行回溯时发现内存中存在数据，就会直接将内存中数据持久化到外部存储目录中,就省去了重新计算的这一步。

一定要避免对RDD进行多次checkPoint。千万不要经常的对RDD进行checkpoint,因为每次checkpoint一次就会存到磁盘一次,过多存储就会和mapreduce在磁盘存储一样了,这样会让application执行缓慢

注意

cache和persist都是懒执行，必须有一个action类算子触发执行,最小单位是partition。
cache和persist算子的返回值可以赋值给一个变量，在其他job中直接使用这个变量就是使用持久化的数据了。持久化的单位是partition。
cache和persist算子后不能立即紧跟action算子。(如:lines.cache().collect()是不行的)
cache和persist算子持久化的数据当applilcation执行完成之后会被清除。
cache和persist不需要指定目录,spark集群会默认为cache,persist创建目录

cache和persist的目录在application执行完后会清空

错误：rdd.cache().count() 返回的不是持久化的RDD，而是一个数值了。

checkpoint相比cache和persist多了一个功能:存储元数据.checkpoint真正用在持久化数据上用的其实并不多,还可以切断RDD之间的依赖关系
checkpoint需要指定目录,cache和persist不需要指定目录,spark集群会默认为cache,persist创建目录

cache和persist的数据在application执行完后会自动清空

checkpoint的数据不会被清空

Checkpoint的数据可以由外部的存储系统管理。程序运行结束后，目录仍然不会被删除。
checkpoint由外部的存储系统管理,persist是由Spark内部管理
checkpoint可以将状态保存到外部,Spark可以基于外部的存储状态恢复