1.原理
Spark的一个重要特性就是共享变量。默认情况下，如果在一个算子的函数中使用到某个外部的变量，那么这个变量的值会被拷贝到每个task中。此时每个task都只能操作自己的变量副本，如果多个task想要共享某个变量，那么这种方式是无法实现的。
Spark为了解决task共享变量的问题，提供了两种变量。一种是Broadcast Variable(广播变量)，另一种是Accumulator(累计变量)。Broadcast Variable将使用的变量，为每个节点拷贝一份，更大的用处是优化性能，减少网络传输以及内存消耗。Accumulator则可以让多个task共同操作一份变量，主要进行累加操作。
1.1 Broadcast Variable
Spark提供的Broadcast Variable，是只读的，并且在每个节点上只会有一份副本，而不会为每个task都拷贝一份副本。因此其最大作用，就是减少变量到各个节点的网络传输消耗，以及在各个节点的内存消耗。此外，Spark自己内部也使用了高效的广播算法来减少网络消耗。
可以通过调用SparkContext的broadcast()方法，来针对某个变量创建广播变量。然后在算子的函数内，使用到广播变量时，每个节点只会拷贝一份副本。每个节点可以使用广播变量的value()方法获取值，记住广播变量，是只读的。
1.2 Accumulator
Spark提供的Accumulator，主要用于多个节点对一个变量进行共享性的操作。Accumulator只提供了累加的功能。即确提供了多个task对一个变量并行操作的功能。但是task只能对Accumulator进行累加操作，不能读取Accumulator的值，只有Driver程序可以读取Accumulator的值。
2.代码实现
2.1 Java代码实现
public class BroadcastVariable { //广播变量
public static void main(String []args){
SparkConf conf = new SparkConf()
.setAppName("broadcast")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//广播变量
int factor = 3;
final Broadcast<Integer> brocast = sc.broadcast(factor);
List<Integer> numbers = Arrays.asList(1,2,3,4,5);
JavaRDD<Integer> numRDD = sc.parallelize(numbers,1);
JavaRDD<Integer> broadRDD = numRDD.map(new Function<Integer, Integer>() {
public Integer call(Integer v1) throws Exception {
return v1 * brocast.value(); //只读<读取广播变量>
}
});
broadRDD.foreach(new VoidFunction<Integer>() {
public void call(Integer v1) throws Exception {
System.out.println(v1);
}
});
sc.close();
}
}
public class AccumulatorVariable { //Accumulator累加器
public static void main(String []args){
SparkConf conf = new SparkConf()
.setAppName("accumulator")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
final Accumulator<Integer> sum = sc.accumulator(0);
List<Integer> numbers = Arrays.asList(1,2,3,4,5);
JavaRDD<Integer> numberRDD = sc.parallelize(numbers);
numberRDD.foreach(new VoidFunction<Integer>() {
public void call(Integer v1) throws Exception {
sum.add(v1);
}
});
System.out.println(sum);
sc.close();
}
}
2.2 Scal代码实现
object BroadcastVariable { //广播变量
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName("broabcast")
.setMaster("local")
val sc = new SparkContext(conf)
val factor = 3
val broadcast = sc.broadcast(factor)
val numbers = Array(1,2,3,4,5)
val numberRDD = sc.parallelize(numbers,1)
val nRDD = numberRDD.map(row => {
row * broadcast.value //只读<读取广播变量>
})
nRDD.foreach(item => {println(item)})
sc.stop()
}
}
//累加变量
object AccumulatorVariable {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName("accumulatorVariable")
.setMaster("local")
val sc = new SparkContext(conf)
val sum = sc.accumulator(0)
val numberRDD = sc.parallelize(Array(1,2,3,4,5),1)
numberRDD.foreach(item => {sum.add(item)})
println(sum)
sc.stop()
}
}
共同学习，写下你的评论
评论加载中...
作者其他优质文章
