Spark | Broadcast和Accumulator机制解密

转自 https://blog.csdn.net/duan_zhihua/article/details/72858601

Spark的Broadcast和Accumulator很重要，在实际的企业级开发环境中一般会使用Broadcast和Accumulator。Broadcast和Accumulator和RDD是Spark中并列的三大基础数据结构。大家谈Spark的时候首先谈RDD，RDD是一个并行的数据，关注在jvm中怎么处理数据。很多时候可能忽略了Broadcast和Accumulator，这2个变量都是全局级别的，例如集群中有1000台机器，那Broadcast和Accumulator可以在1000台机器中共享。在分布式的基础之上，如果有共享的数据结构，那是非常有用的。

分布式大数据系统中，我们进行编程的时候首先考虑数据结构：

l RDD: 分布式私有数据结构。RDD本身是一个并行化的本地化的数据结构，运行的时候在一个个线程中运行，RDD是私有的运行数据和私有的运行过程，但在一个Stage里面是一样的，一个线程一个时刻只处理一个数据分片，另一个线程一个时刻只处理另一个数据片。在设计业务逻辑的时候，我们通常考虑这个分片如何去处理。

l Broadcast：分布式全局只读数据结构。

l Accumulator：分布式全局只写的数据结构。我们不会在线程池中读取Accumulator，但在Driver上可以读取Accumulator。

在生产环境下，我们几乎一定会自定义Accumulator：

1，自定义的时候可以让Accumulator非常复杂，基本上可以是任意类型的Java和Scala对象；

2，在自定义Accumulator的时候，我们可以实现一些“技术福利”，例如在Accumulator变化的时候可以把数据同步到MySQL中；例如，我们在进行流处理的时候，数据不断的流进来，如要查询用户点击量的趋势图，计算点击量以后需实时反馈到生产环境的server上。一个非常简单的实现方式是：每次发现累加的时候，就更新一下数据库，这是一个非常强大的同步机制和同步效果。

Accumulator是一个简单value值 [[Accumulable]] ，相同类型的元素合并时候结果可以累加，通过“added”到关联和交换操作，可以有效地支持并行。可以用来实现计数（如MapReduce）或求和。Spark 原生支持数值类型的累加器，也可以自定义开发实现新类型的支持。

累加器由一个初始值“V”通过调用[[SparkContext#accumulator SparkContext.accumulator]]创建。在群集上运行的任务可以使用 +=运算符写入，但是不能读取它的值。只有Driver程序使用[[#value]] 方法可以读取累加器的值。例如：

1. scala> val accum = sc.accumulator(0)

2. accum: org.apache.spark.Accumulator[Int] = 0

3. scala> sc.parallelize(Array(1, 2, 3,4)).foreach(x => accum += x)

4. …

5. 10/09/29 18:41:08 INFO SparkContext: Tasksfinished in 0.317106 s

7. scala> accum.value

8. res2: Int = 10

Accumulator.scala源码如下：

1. @deprecated(“useAccumulatorV2”, “2.0.0”)

2. class Accumulator[T]private[spark] (

3. // SI-8813: This must explicitly be aprivate val, or else scala 2.11 doesn’t compile

4. @transient private val initialValue: T,

5. param: AccumulatorParam[T],

6. name: Option[String] = None,

7. countFailedValues: Boolean = false)

8. extends Accumulable[T, T](initialValue,param, name, countFailedValues)

9. ……

Accumulator是一个类，继承至Accumulable，Accumulator已经被标识过时的（deprecated），在Spark 2.0版本中可以使用AccumulatorV2。

1. abstract class AccumulatorV2[IN, OUT] extendsSerializable {

2. private[spark] var metadata:AccumulatorMetadata = _

3. private[this] var atDriverSide = true

4. ……

我们可以通过继承创建自己的类型AccumulatorV2。AccumulatorV2抽象类有几种方法必须覆盖：reset用于将累加器重置为零，add用于将另一个值添加到累加器中，merge用于将另一个相同类型的累加器合并到该累加器中。例如，假设有一个MyVector代表数学向量的类，代码如下：

1. class VectorAccumulatorV2 extendsAccumulatorV2[MyVector, MyVector] {

3. private val myVector: MyVector =MyVector.createZeroVector

5. def reset(): Unit = {

6. myVector.reset()

7. }

9. def add(v: MyVector): Unit = {

10. myVector.add(v)

11. }

12. …

13. }

15. // Then, create an Accumulatorof this type:

16. val myVectorAcc = newVectorAccumulatorV2

17. // Then, register it into sparkcontext:

18. sc.register(myVectorAcc,”MyVectorAcc1”)

当自定义自己的AccumulatorV2类型时，生成的类型可能与添加的元素的类型不同。累加器更新仅在Action动作内执行，Spark保证每个任务对累加器的更新只能应用一次，即重新启动的任务将不会更新该值。在transformations转换中，如果重新执行任务或作业阶段，则每个任务的更新可能会被多次执行。Accumulators不会改变Spark的 lazy评估模型。如果它们在RDD的操作中更新，则只有在RDD作为操作的一部分进行计算时，才会更新其值。因此，累加器更新不能保证在 lazy变换中执行时执行map()。

以下代码中 accum仍然为0 ，因为没有aciton算子触发map操作。

1. val accum = sc.longAccumulator

2. data.map { x =>accum.add(x); x }