大数据

Spark 7. 共享变量

共享变量

原文地址: http://spark.apache.org/docs/latest/programming-guide.html#shared-variables
仅限交流使用,转载请注明出处。如有错误,欢迎指出!

Henvealf/译

一般情况下, Spark 的 map 或者 reduce 操作(task)的方法是运行在远程的集群节点上的,且会在每一个操作上复制一份变量。因为节点之间的变量不会共享,所以在远程机器上的变量的更新不会传播到驱动器程序上。通用的解决方法,就是使用可以被全部的 task 读写的共享变量,但他会拖慢运行效率。然而, Spark 还是为两种普遍的使用模式提供了两种共享变量的受限类型:广播变量与增量器。

广播变量(Broadcast Variables)

广播变量允许在每个机器中的程序里维护一个只读的缓存变量,而不是在每个 task 中传送一个拷贝。他能够被用于,举例来说,他会使用一种高效率的方式为每个节点提供一份大的输入数据集的拷贝。Spark 也尝试使用一个高效率的广播算法去减少分发广播变量时的交互开销。

Spark 的 actions 的执行会经历一系列通过分布式的 “shuffle” 操作来分离的阶段。Spark 需要各个阶段中的 task 来自动广播公用的数据。数据广播的方式缓存进序列化结构和在运行每一个 task 之前进行反序列化。这意味着仅仅当task经过了需要相同数据的多个阶段时,或者按照序列化结构缓存数据是重要的时候,才确定创建广播变量。

通过调用 SparkContext.boradcast(v), 就可以从变量 v 中创建出一个广播变量。变量 v 此时已经被包装进了广播变量在中,可以在调用 value() 函数,来获取到变量。示例代码如下:

Scala

scala> val broadcastVar = sc.broadcast(Array(1, 2, 3))
broadcastVar: org.apache.spark.broadcast.Broadcast[Array[Int]] = Broadcast(0)

scala> broadcastVar.value
res0: Array[Int] = Array(1, 2, 3)

Java

Broadcast broadcastVar = sc.broadcast(new int[] {1, 2, 3});

broadcastVar.value();
// returns [1, 2, 3]

创建了一个广播变量之后,在集群上运行的任何方法中,都应该使用广播变量来代替与 v 中的值相同的变量,这样就可以避免 v 的值在节点上出现了两次。另外,v 的值不要去修改,确保在所有节点上的广播变量都是相同的值。

增量器 (Accumulators)

增量器是一个只能进行加操作的变量,用于操作之间的协作与交互,因此他也支持高效率的并发。很像 MapReduce 中的 Counter。原生的增量器支持数字类型,现在程序可以支持新的类型。

如果你给了增量器一个名字,那个你就能在 Spark UI 上看到他。通过他来理解程序运行的各个阶段(注意,在 Python 中并不支持)。

Scala

一个数字增量器可以通过调用 SparkContext.longAccumulator() 或者 SparkContext.doubleAccumulator() 来创建。然后在集群上使用 add 方法来进行加操作。然而,集群不能读取他的值。只可以在驱动器程序上读取增量器的值。使用 value() 方法。

下面就使用增量气来将一个数组中的值加一块:

scala> val accum = sc.longAccumulator("My Accumulator")
accum: org.apache.spark.util.LongAccumulator = LongAccumulator(id: 0, name: Some(My Accumulator), value: 0)

scala> sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum.add(x))
...
10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s

scala> accum.value
res2: Long = 10

上面上使用原生的数字类型的增量器。下面看看如何创建一个自定义类型的增量器。你的增量器需要继承 AccumulatorV2 抽象类。你需要重写(override)他的几个方法:

  • reset : 将迭代器中的值设置为 0。
  • add:增加增量器中的值。
  • merge: 合并其他同类型的增量器。

其他需要重写的方法请看 Scala API 文档。

下面我们有一个 MyVector 类,代表了数学上的向量,下面就是 MyVector 的实现类:

object VectorAccumulatorV2 extends AccumulatorV2[MyVector, MyVector] {
  val vec_ : MyVector = MyVector.createZeroVector
  def reset(): MyVector = {
    vec_.reset()
  }
  def add(v1: MyVector, v2: MyVector): MyVector = {
    vec_.add(v2)
  }
  ...
}

// Then, create an Accumulator of this type:
val myVectorAcc = new VectorAccumulatorV2
// Then, register it into spark context:
sc.register(myVectorAcc, "MyVectorAcc1")

增量器的更新在内部执行的 仅仅是 action 。 Spark 保证每个 task 在增量器上的更新仅仅被应用一次,也就是说,重启 task 将不会更新值。在 transformations 中,用户应该知道,如果 job 的阶段被重新运行,每一个 task 的更新会被应用多次。

迭代器不会改变 Spark 的懒惰评估。如果更新操作是作用在一个 RDD 上,他的值将只会 在作为action 的一部分 来进行计算之后才进行更新。随之而来的,当使用一个懒惰的 transformation(比如 map() )来更新值,增量器不会保证一定执行更新, 下面的代码就展示了所说的情况:

Scala

val accum = sc.longAccumulator
data.map { x => accum.add(x); x }
// 这里 accum 将一直为 0, 因为没有 action 来触发 `map` 任务的计算。

Java

LongAccumulator accum = jsc.sc().longAccumulator();
data.map(x -> { accum.add(x); return f(x); });
// 这里 accum 将一直为 0, 因为没有 action 来触发 `map` 任务的计算。

Python

accum = sc.accumulator(0)
def g(x):
  accum.add(x)
  return f(x)
data.map(g)

End !!