Spark持久化、broadcast广播变量和accumulator累加器

持久化操作

什么是持久化，为什么要持久化

Spark中最重要的功能之一是跨操作在内存中持久化（或缓存）数据集。当您持久化RDD时，每个节点将其计算的任何分区存储在内存中，并在该数据集（或从该数据集派生的数据集）上的其他操作中重用这些分区。这使得未来的行动更快（通常超过10倍）。缓存是迭代算法和快速交互使用的关键工具。

可以使用persist（）或cache（）方法将RDD标记为持久化。第一次在动作中计算时，它将保存在节点的内存中。Spark的缓存是容错的——如果RDD的任何分区丢失，它将使用最初创建它的转换自动重新计算。

持久化的方法就是rdd.persist()或者rdd.cache()。

持久化策略

可以通过persist(StoreageLevle的对象)来指定持久化策略,eg:StorageLevel.MEMORY_ONLY。

持久化策略

含义

MEMORY_ONLY(默认)

rdd中的数据，以未经序列化的java对象格式，存储在内存中。如果内存不足，剩余的部分不持久化，使用的时候，没有持久化的那一部分数据重新加载。这种效率是最高，但是是对内存要求最高的。

MEMORY_ONLY_SER

就比MEMORY_ONLY多了一个SER序列化，保存在内存中的数据是经过序列化之后的字节数组，同时每一个partition此时就是一个比较大的字节数组。

MEMORY_AND_DISK

和MEMORY_ONLY相比就多了一个disk，内存存不下的数据存储在磁盘中。

MEMEORY_AND_DISK_SER

比MEMORY_AND_DISK多了个序列化。

DISK_ONLY

就是MEMORY_ONLY对应，都保存在磁盘，效率太差，一般不用。

xxx_2

就是上述多个策略后面加了一个_2,比如MEMORY_ONLY_2，MEMORY_AND_DISK_SER_2等等，就多了一个replicate而已，备份，所以性能会下降，但是容错或者高可用加强了。所以需要在二者直接做权衡。如果说要求数据具备高可用，同时容错的时间花费比从新计算花费时间少，此时便可以使用，否则一般不用。

HEAP_OFF(experimental)

使用非Spark的内存，也即堆外内存，比如Tachyon，HBase、Redis等等内存来补充spark数据的缓存。

如何选择一款合适的持久化策略

第一就选择默认MEMORY_ONLY，因为性能最高嘛，但是对空间要求最高；如果空间满足不了，退而求其次，选择MEMORY_ONLY_SER,此时性能还是蛮高的，相比较于MEMORY_ONLY的主要性能开销就是序列化和反序列化；如果内存满足不了,直接跨越MEMORY_AND_DISK，选择MEMEORY_AND_DISK_SER，因为到这一步，说明数据蛮大的，要想提高性能，关键就是基于内存的计算，所以应该尽可能的在内存中存储对象；DISK_ONLY不用，xx_2的使用如果说要求数据具备高可用，同时容错的时间花费比从新计算花费时间少，此时便可以使用，否则一般不用。

持久化和非持久化性能比较

object _05SparkPersistOps {def main(args: Array[String]): Unit = {val conf = new SparkConf().setAppName(s"${_05SparkPersistOps.getClass.getSimpleName}").setMaster("local[*]")val sc = new SparkContext(conf)//读取外部数据（文件125M大小）var start = System.currentTimeMillis()val lines = sc.textFile("file:///E:/data/spark/core/sequences.txt")var count = lines.count()println("没有持久化：#######lines' count: " + count + ", cost time: " + (System.currentTimeMillis() - start) + "ms")lines.persist(StorageLevel.MEMORY_AND_DISK) //lines.cache()start = System.currentTimeMillis()count = lines.count()println("持久化之后：#######lines' count: " + count + ", cost time: " + (System.currentTimeMillis() - start) + "ms")lines.unpersist()//卸载持久化数据sc.stop()}}

RDD检查点机制

Spark中对于数据的保存除了持久化操作之外，还提供了一种检查点的机制，检查点（本质是通过将RDD写入Disk做检查点）是为了通过lineage做容错的辅助，lineage过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果之后有节点出现问题而丢失分区，从做检查点的RDD开始重做Lineage，就会减少开销。检查点通过将数据写入到HDFS文件系统实现了RDD的检查点功能。

cache 和 checkpoint 是有显著区别的，缓存把 RDD 计算出来然后放在内存中，但是RDD 的依赖链（相当于数据库中的redo 日志），也不能丢掉，当某个节点某个 executor 宕机了，上面cache 的RDD就会丢掉，需要通过依赖链重放计算出来，不同的是checkpoint 是把 RDD 保存在 HDFS中，是多副本可靠存储，所以依赖链就可以丢掉了，就斩断了依赖链，是通过复制实现的高容错。

如果存在以下场景，则比较适合使用检查点机制：

1）DAG中的Lineage过长，如果重算，则开销太大（如在PageRank中）。

2）在宽依赖上做Checkpoint获得的收益更大。

为当前RDD设置检查点。该函数将会创建一个二进制的文件，并存储到checkpoint目录中，该目录是用SparkContext.setCheckpointDir()设置的。在checkpoint的过程中，该RDD的所有依赖于父RDD中的信息将全部被移出。对RDD进行checkpoint操作并不会马上被执行，必须执行Action操作才能触发。

def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("wc").setMaster("spark://CentOS1:7077")
val sc = new SparkContext(conf)
val spark = SparkSession.builder().config(conf).getOrCreate()
val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8),("a",33),("c",6)),3)
sc.setCheckpointDir("hdfs://CentOS1:9000/checkpoint")
rdd.checkpoint()
rdd.collect
println(rdd.collect.toBuffer)}
}

共享变量

概述

通常，当传递给Spark操作（如map或reduce）的函数在远程集群节点上执行时，它将在函数中使用的所有变量的单独副本上工作。这些变量被复制到每台机器上，对远程机器上变量的更新不会传播回驱动程序。跨任务支持通用的读写共享变量将是低效的(低效). 然而，Spark确实为两种常见的使用模式提供了两种有限类型的共享变量：广播变量和累加器。

就是说，为了能够更加高效的在driver和算子之间共享数据，spark提供了两种有限的共享变量，一者广播变量，一者累加器。

broadcast广播变量

说明

如果我们要在分布式计算里面分发大对象，例如：字典，集合，黑白名单等，这个都会由Driver端进行分发，一般来讲，如果这个变量不是广播变量，那么每个task就会分发一份，这在task数目十分多的情况下Driver的带宽会成为系统的瓶颈，而且会大量消耗task服务器上的资源，如果将这个变量声明为广播变量，那么只是每个executor拥有一份，这个executor启动的task会共享这个变量，节省了通信的成本和服务器的资源。

图-23 广播变量图

如何使用广播变量呢？对普通遍历进行包装即可。

val num:Any = xxx

val numBC:Broadcast[Any] = sc.broadcast(num)

调用

val n = numBC.value

编码操作

val conf = new SparkConf()
conf.setMaster("local[*]").setAppName("brocast")
val sc = new SparkContext(conf)
sc.setLogLevel("WARN")
val list = List("hello hadoop")
val broadCast = sc.broadcast(list)
val lineRDD = sc.textFile("E:\\word.txt")
lineRDD.filter { x => broadCast.value.contains(x) }.foreach(println)sc.stop()

定义广播变量注意点

变量一旦被定义为一个广播变量，那么这个变量只能读，不能修改。

注意事项

1)能不能将一个RDD使用广播变量广播出去？不能，因为RDD是不存储数据的。可以将RDD的结果广播出去。

2)广播变量只能在Driver端定义，不能在Executor端定义。

3)在Driver端可以修改广播变量的值，在Executor端无法修改广播变量的值。

4)如果executor端用到了Driver的变量，如果不使用广播变量在Executor有多少task就有多少Driver端的变量副本。

5)如果Executor端用到了Driver的变量，如果使用广播变量在每个Executor中只有一份Driver端的变量副本。

accumulator累加器

说明

accumulator累加器的概念和mr中出现的counter计数器的概念有异曲同工之妙，对某些具备某些特征的数据进行累加。累加器的一个好处是，不需要修改程序的业务逻辑来完成数据累加，同时也不需要额外的触发一个action job来完成累加，反之必须要添加新的业务逻辑，必须要触发一个新的action job来完成，显然这个accumulator的操作性能更佳！

累加的使用：

构建一个累加器

val accu = sc.longAccumuator()

累加的操作

accu.add(参数)

获取累加器的结果，累加器的获取，必须需要action的触发

val ret = accu.value

编码操作

1)使用非累加器完成某些特征数据的累加求解：

val sc = new SparkContext(conf)val lines = sc.textFile("file:/E:/work/data/accu.txt")val words = lines.flatMap(_.split("\\s+"))//统计每个单词出现的次数val rbk = words.map((_, 1)).reduceByKey(_+_)rbk.foreach(println)println("=============额外的统计=================")//统计其中的is出现的次数rbk.filter{case (word, count) => word == "is"}.foreach(println)Thread.sleep(10000000)sc.stop()

执行结果如图-24所示。

图-24 非累加器执行结果

2)使用累加器完成上述案例：

val conf = new SparkConf().setAppName(s"${AccumulatorOps.getClass.getSimpleName}").setMaster("local[*]")val sc = new SparkContext(conf)val lines = sc.textFile("file:/E:/work/data/accu.txt")val words = lines.flatMap(_.split("\\s+"))//统计每个单词出现的次数val accumulator = sc.longAccumulatorval rbk = words.map(word => {if(word == "is")accumulator.add(1)(word, 1)}).reduceByKey(_+_)rbk.foreach(println)println("================使用累加器===================")println("is： " + accumulator.value)Thread.sleep(10000000)sc.stop()

执行结果入下图-25所示。

图-25 累加器执行结果

3)总结：使用累加器也能够完成上述的操作，而且只使用了一个action操作。

注意

1)累加器的调用，也就是accumulator.value必须要在action之后被调用，也就是说累加器必须在action触发之后。

2)多次使用同一个累加器，应该尽量做到用完即重置:accumulator.reset

3)尽量给累加器指定name，方便我们在web-ui上面进行查看，如图-26所示。

图-26 有名字的累加器

自定义累加器

自定义累加器类型的功能在1.X版本中就已经提供了，但是使用起来比较麻烦，在2.0版本后，累加器的易用性有了较大的改进，而且官方还提供了一个新的抽象类：AccumulatorV2来提供更加友好的自定义类型累加器的实现方式。实现自定义类型累加器需要继承AccumulatorV2并至少覆写下例中出现的方法，下面这个累加器可以用于在程序运行过程中统计单词出现的次数，最终以HashMap[String,Int]的形式返回。

import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutableclass CustomerAcc extends AccumulatorV2[String, mutable.HashMap[String, Int]] {private val _hashAcc = new mutable.HashMap[String, Int]()// 检测是否为空override def isZero: Boolean = {
_hashAcc.isEmpty}// 拷贝一个新的累加器,//有可能多个task同时往初始值里写值，有可能出现线程安全问题，此时最好加锁override def copy(): AccumulatorV2[String, mutable.HashMap[String, Int]] = {
val newAcc = new CustomerAcc()
_hashAcc.synchronized {newAcc._hashAcc ++= (_hashAcc)
}
newAcc}// 重置一个累加器override def reset(): Unit = {
_hashAcc.clear()}// 每一个分区中用于添加数据的方法 小SUMoverride def add(v: String): Unit = {
_hashAcc.get(v) match {case None => _hashAcc += ((v, 1))case Some(a) => _hashAcc += ((v, a + 1))
}}// 合并每一个分区的输出 总sumoverride def merge(other: AccumulatorV2[String, mutable.HashMap[String, Int]]): Unit = {
other match {case o: AccumulatorV2[String, mutable.HashMap[String, Int]] => {
for ((k, v) <- o.value) {_hashAcc.get(k) match {
case None => _hashAcc += ((k, v))
case Some(a) => _hashAcc += ((k, a + v))}
}}
}}// 输出值override def value: mutable.HashMap[String, Int] = {
_hashAcc}}

注册使用：

object CustomerAcc {def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setAppName("partittoner").setMaster("local[*]")
val sc = new SparkContext(sparkConf)
val abc = "HIII"
val hashAcc = new CustomerAcc()
sc.register(hashAcc, "abc")
val rdd = sc.makeRDD(Array("a", "b", "c", "a", "b", "c", "d"))
rdd.foreach(hashAcc.add(_))
for ((k, v) <- hashAcc.value) {println("【" + k + ":" + v + "】")
}
sc.stop()}
}