
文章目录
Spark广播变量与累加器详解
在 Spark 分布式计算中,数据需要在 Driver 端与 Executor 端之间高效流转。广播变量(Broadcast Variable)和累加器(Accumulator)是 Spark 提供的两种共享变量机制:前者用于将只读数据高效分发到各个节点,后者用于将 Executor 端的更新安全地聚合回 Driver 端。本文结合示例代码,系统讲解两者的原理、使用方式与注意事项。
一、广播变量
如下 Spark 伪代码过滤黑名单示例中,blackList 列表会被序列化并随着每个 task 发送到各个 Executor 中,每个 task 都会携带一份独立的 blackList。如果 blackList 数据量大且 task 个数多,会导致 Executor 端的内存和网络传输开销显著增大。
Scala
val conf = new SparkConf().setMaster(...).setAppName(...)
val sc = new SparkContext(conf)
val blackList = List("a", "b", "c")
val rdd: RDD[String] = sc.textFile("...")
val result = rdd.filter(name => {
!blackList.contains(name)
})
result.foreach(println)
sc.stop()
对于需要在多个 task 中重复使用的大型数据集,Spark 提供了广播变量机制。广播变量通过将数据在各节点间进行高效广播,确保每个节点仅保留一份数据副本,从而显著减少 Executor 端的内存和网络传输消耗。
结合以上示例,广播变量理解图和工作原理如下:

广播变量由 BroadcastManager 对象进行管理,负责广播变量的创建、分发和生命周期管理。Executor 端在需要使用广播变量时,会首先从本地的 BlockManager 获取相应的数据块;如果本地不存在,则会从 Driver 拉取所需的数据块,并缓存到本地的 BlockManager 中,以供后续任务使用。
使用广播变量时需要注意如下几点:
- 广播变量只能在 Driver 端定义,Executor 端无法修改广播变量的值;如果需要更新广播变量,必须在 Driver 端重新创建新的广播变量。
- 在 Executor 端使用广播变量时,需通过广播变量的 value 方法获取广播的数据集。
- 不能将 RDD 广播出去,因为 RDD 不存储数据;可以将 RDD 的结果回收为集合后再进行广播。
下面演示广播变量在 Java 和 Scala API 中的使用。
Java 代码:
java
SparkConf conf = new SparkConf().setMaster("local").setAppName("broadcastTest");
JavaSparkContext sc = new JavaSparkContext(conf);
//定义黑名单
List<String> blackList = Arrays.asList("zs", "lisi");
//将黑名单广播出去
Broadcast<List<String>> broadcast = sc.broadcast(blackList);
JavaRDD<String> rdd = sc.parallelize(Arrays.asList("zs", "lisi", "wangwu", "maliu", "tianqi"));
JavaRDD<String> result = rdd.filter(name -> {
//获取广播变量
List<String> bcBlackList = broadcast.value();
//判断是否在黑名单中
return !bcBlackList.contains(name);
});
result.foreach(name->System.out.println(name));
sc.stop();
Scala 代码:
Scala
val conf: SparkConf = new SparkConf().setMaster("local").setAppName("BroadCastTest")
val sc = new SparkContext(conf)
//定义黑名单
val blackList = List("zhangsan", "lisi")
//将黑名单广播出去
val broadcast: Broadcast[List[String]] = sc.broadcast(blackList)
val rdd: RDD[String] = sc.parallelize(List("zhangsan", "lisi", "wangwu", "zhaoliu"))
//使用黑名单对rdd进行过滤
val result: RDD[String] = rdd.filter(x => {
//获取广播变量中的黑名单
val bcBlackList: List[String] = broadcast.value
//对rdd中的数据进行过滤
!bcBlackList.contains(x)
})
result.foreach(println)
sc.stop()
二、累加器
如下 Spark 代码案例进行数据条数统计,数据总条数为 100:
Scala
val conf: SparkConf = new SparkConf().setMaster("local").setAppName("accumulatorTest")
val sc = new SparkContext(conf)
//Driver端定义变量
var cnt=0
val rdd: RDD[Int] = sc.parallelize(1 to 100)
val result: RDD[Int] = rdd.map(x => {
//Executor端累加
cnt += 1
x
})
result.count()
println(s"总条数为:$cnt")
sc.stop()
在上述代码中,cnt 变量在 Driver 端定义,但在 map 算子中对其进行累加操作。由于 map 算子在 Executor 端执行,每个任务都会有自己独立的 cnt 副本,导致这些累加操作不会影响 Driver 端的 cnt 变量。因此,最终输出的 cnt 结果仍为初始值 0。
对于需要在所有任务之间共享并累加的变量,就可以使用 Spark 中的累加器。累加器(Accumulator)用于对数据进行累加操作,在 Driver 端定义,各个 Executor 的 task 可以对其进行更新,Spark 会自动将这些更新聚合到 Driver 端。累加器理解图如下:

使用累加器时需要注意:累加器只能在 Driver 端读取,在 Executor 端只能执行累加操作;同时,由于 Spark 的惰性求值与任务重试机制,累加器在转换算子中可能被重复累加,因此建议将累加操作放在行动算子触发的执行路径中,或结合业务场景谨慎使用。
特别注意:累加器在Driver端定义赋初始值,累加器只能在Driver端读取,在Excutor端更新(Executor端读取到的数据只是对应task结果)。
Java代码:
java
SparkConf conf = new SparkConf().setMaster("local").setAppName("accumulatorTest");
JavaSparkContext sc = new JavaSparkContext(conf);
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add("value"+i);
}
JavaRDD<String> rdd = sc.parallelize(list,2);
//Driver端定义累加器
LongAccumulator longAccumulator = sc.sc().longAccumulator();
JavaRDD<String> result = rdd.map(new Function<String, String>() {
@Override
public String call(String s) throws Exception {
//Executor端累加器累加
longAccumulator.add(1);
System.out.println("Executor Acc Value:" + longAccumulator.value());
return s;
}
});
result.count();
//Driver端获取累加器的值
System.out.println("Driver Acc Value:" + longAccumulator.value());
sc.stop();
Scala代码:
Scala
val conf: SparkConf = new SparkConf().setMaster("local").setAppName("accumulatorTest")
val sc = new SparkContext(conf)
//Driver端创建累加器
val accumulator: LongAccumulator = sc.longAccumulator
val rdd: RDD[Int] = sc.parallelize(1 to 100,2)
val result: RDD[Int] = rdd.map(x => {
//Executor端累加
accumulator.add(1)
println(s"Executor Acc value :${accumulator.value}")
x
})
result.count()
//Driver端获取累加器的值
println(s"Driver Acc Value:${accumulator.value}")
sc.stop()
三、总结
广播变量与累加器是 Spark 中两种互补的共享变量机制,核心区别如下:
| 对比项 | 广播变量 | 累加器 |
|---|---|---|
| 数据流向 | Driver 到 Executor(只读分发) | Executor 到 Driver(聚合回传) |
| 可修改性 | Executor 端只读,不可修改 | Executor 端可累加,Driver 端可读取 |
| 典型场景 | 黑名单过滤、字典映射、配置分发 | 计数统计、求和、异常数据统计 |
| 核心价值 | 减少内存占用与网络传输 | 避免 Driver 与 Executor 变量不同步 |
在实际开发中,合理使用广播变量可以显著降低大表关联和字典查找的开销,而累加器则适合做全局计数与监控指标收集。掌握两者的适用边界,是编写高效 Spark 作业的重要基础。
- 📢博客主页:https://lansonli.blog.csdn.net
- 📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正!
- 📢本文由 Lansonli 原创,首发于 CSDN博客🙉
- 📢停下休息的时候不要忘了别人还在奔跑,希望大家抓紧时间学习,全力奔赴更美好的生活✨