一、共享变量的工作原理
Spark还有一个非常重要的特性就是共享变量。默认情况下,如果在一个算子函数中使用到了某个外部的变量,那么这个变量的值会被拷贝到每个task中。此时每个task只能操作自己的那份变量数据。如果多个task想要共享某个变量,那么这种方式是做不到的
Spark为此提供了两种共享变量:
(1)Broadcast Variable(广播变量)
(2)Accumulator(累加变量)
二、广播变量
- Broadcast Variable会将使用到的变量,仅仅为每个节点拷贝一份,而不是每个task,能够优化性能,减少网络传输及内存消耗
- 通过SparkContext的broadcast()方法,针对某个变量创建广播变量,可以通过广播变量的value()方法获取值
- 广播变量是只读的
大家可以想象一个极端情况,如果map算子有10个task,恰好这10个task还都在一个worker节点上,那么这个时候,map算子使用的外部变量就会在这个worker节点上保存10份,这样就很占用内存了。
1. Scala代码
package com.sanqian.scala
import org.apache.spark.{SparkConf, SparkContext}
object BroadcastOpScala {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
conf.setAppName("BroadcastOpScala").setMaster("local[*]")
val sc = new SparkContext(conf)
val rdd = sc.parallelize(Array(1, 2, 3, 4, 5))
val varable = 2
// rdd.map(_ * varable).foreach(println(_))
// 1.定义广播变量
val varableBroad = sc.broadcast(varable)
// 2.使用广播变量,调用value方法
rdd.map(_ * varableBroad.value).foreach(println(_))
sc.stop()
}
}
2. Java代码
package com.sanqian.java;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.VoidFunction;
import org.apache.spark.broadcast.Broadcast;
import java.util.Arrays;
import java.util.List;
public class BroadcastOpJava {
public static void main(String[] args) {
SparkConf conf = new SparkConf();
conf.setAppName("BroadcastOpJava").setMaster("local[*]");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
JavaRDD<Integer> rdd = sc.parallelize(list);
int varable = 2;
// 1.定义广播变量
Broadcast<Integer> varableBroad = sc.broadcast(varable);
// 2.使用广播变量
rdd.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer v1) throws Exception {
return v1 * varableBroad.value();
}
}).foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println(integer);
}
});
sc.stop();
}
}
三、累加变量
Spark提供的Accumulator,主要用于多个节点对一个变量进行共享性的操作。正常情况下在Spark的任务中,由于一个算子可能会产生多个task并行执行,所以在这个算子内部执行的聚合计算都是局部的,想要实现多个task进行全局聚合计算,此时需要使用到Accumulator这个共享的累加变量。
注意:Accumulator只提供了累加的功能。在task只能对Accumulator进行累加操作,不能读取它的值。只有在Driver进程中才可以读取Accumulator的值。
1. Scala代码
package com.sanqian.scala
import org.apache.spark.{SparkConf, SparkContext}
object AccumulatorOpScala {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
conf.setAppName("AccumulatorOpScala").setMaster("local[*]")
val sc = new SparkContext(conf)
val rdd = sc.parallelize(Array(1, 2, 3, 4, 5))
// 这种写法是错误的,因为foreach代码是在worker节点上执行的
//var total = 0 和 println("total:" + total) 是在driver进程中执行的
//所以无法实现累加操作, 并且foreach算子可能会在多个task中执行,这样foreach内部实现的累加也不是最终
//全局累加的结果
// var total = 0
// rdd.foreach(num => total += num)
// println("total:" + total)
// 1: 定义累加变量
val sumAccumulator = sc.longAccumulator
// 2:使用累加变量
rdd.foreach(num=>sumAccumulator.add(num))
// 注意只能在driver进程中获取累加变量的结果
println(sumAccumulator.value)
sc.stop()
}
}
2. Java代码
package com.sanqian.java;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.VoidFunction;
import org.apache.spark.util.LongAccumulator;
import java.util.Arrays;
public class AccumulatorOpJava {
public static void main(String[] args) {
SparkConf conf = new SparkConf();
conf.setAppName("AccumulatorOpJava").setMaster("local[*]");
JavaSparkContext sc = new JavaSparkContext(conf);
JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
//1:定义累加变量
LongAccumulator sumAccumulator = sc.sc().longAccumulator();
//2: 使用累加变量
rdd.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
sumAccumulator.add(integer);
}
});
//获取累加变量的值
System.out.println(sumAccumulator.value());
}
}