在 PySpark 中，累加器（Accumulator）是一种特殊的共享变量，用于在分布式计算中安全地聚合来自多个 Executor 节点的数据到 Driver 节点。它主要解决了分布式环境下跨节点状态共享的问题，特别适合计数、求和等聚合操作。
累加器的核心特性
- 单向通信：Executor 只能对累加器执行更新操作，不能读取其值；只有 Driver 可以读取累加器的最终结果
- 分布式安全：Spark 会自动处理任务重试时的累加器更新，确保结果正确性
- 惰性执行：累加器的更新只有在 Action 操作触发时才会真正执行
- 容错性：当任务失败重新计算时，Spark 会正确处理累加器的状态
累加器的类型
-
内置累加器：
- 数值型累加器（
LongAccumulator、DoubleAccumulator） - 集合累加器（
CollectionAccumulator）
- 数值型累加器（
-
自定义累加器 ：
当内置累加器无法满足需求时，可以通过继承
AccumulatorV2类实现自定义逻辑
内置累加器使用示例
1. 数值型累加器
from pyspark.sql import SparkSession
# 初始化SparkSession
spark = SparkSession.builder \
.appName("PySpark Accumulator Example") \
.master("local[*]") \
.getOrCreate()
sc = spark.sparkContext
# 创建累加器
count_acc = sc.longAccumulator("count_accumulator") # 整数累加器
sum_acc = sc.doubleAccumulator("sum_accumulator") # 浮点数累加器
# 准备数据
data = sc.parallelize(range(1, 11)) # 1到10的数字
# 使用累加器
def process_number(num):
count_acc.add(1) # 计数
sum_acc.add(num) # 求和
data.foreach(process_number)
# 在Driver端获取累加器结果
print(f"总记录数: {count_acc.value}") # 输出: 总记录数: 10
print(f"总和: {sum_acc.value}") # 输出: 总和: 55.0
print(f"平均值: {sum_acc.value / count_acc.value}") # 输出: 平均值: 5.5
spark.stop()2. 集合累加器
集合累加器用于收集分布式计算中的元素：
from pyspark.sql import SparkSession
spark = SparkSession.builder \
.appName("Collection Accumulator Example") \
.master("local[*]") \
.getOrCreate()
sc = spark.sparkContext
# 创建集合累加器
collection_acc = sc.collectionAccumulator("collection_accumulator")
# 准备数据
data = sc.parallelize(["apple", "banana", "apple", "orange", "banana"])
# 使用累加器收集元素
data.foreach(lambda x: collection_acc.add(x))
# 获取结果
print(f"收集到的元素: {collection_acc.value}")
# 可能输出: 收集到的元素: ['apple', 'banana', 'apple', 'orange', 'banana']
# 去重处理
unique_elements = list(set(collection_acc.value))
print(f"唯一元素: {unique_elements}")
# 可能输出: 唯一元素: ['apple', 'banana', 'orange']
spark.stop()自定义累加器示例
当内置累加器不能满足需求时，可以实现自定义累加器。以下是一个统计字符串长度的累加器：
python
from pyspark.sql import SparkSession
from pyspark.util import AccumulatorV2
from typing import Tuple, List
class StringLengthAccumulator(AccumulatorV2[str, Tuple[int, int]]):
"""
自定义累加器，统计字符串总长度和字符串数量
结果为一个元组: (总长度, 总数量)
"""
def __init__(self):
self.total_length = 0 # 总长度
self.count = 0 # 总数量
self.is_zero = True
def reset(self):
"""重置累加器为初始状态"""
self.total_length = 0
self.count = 0
self.is_zero = True
def add(self, value: str):
"""添加一个字符串并更新状态"""
self.total_length += len(value)
self.count += 1
self.is_zero = False
def merge(self, other: "StringLengthAccumulator"):
"""合并另一个累加器的结果"""
self.total_length += other.total_length
self.count += other.count
self.is_zero = (self.total_length == 0 and self.count == 0)
def value(self) -> Tuple[int, int]:
"""返回当前累加器的值"""
return (self.total_length, self.count)
def isZero(self) -> bool:
"""检查累加器是否处于初始状态"""
return self.is_zero
def copy(self) -> "StringLengthAccumulator":
"""复制累加器"""
new_acc = StringLengthAccumulator()
new_acc.total_length = self.total_length
new_acc.count = self.count
new_acc.is_zero = self.is_zero
return new_acc
# 使用自定义累加器
if __name__ == "__main__":
spark = SparkSession.builder \
.appName("Custom String Length Accumulator") \
.master("local[*]") \
.getOrCreate()
sc = spark.sparkContext
# 注册自定义累加器
str_acc = StringLengthAccumulator()
sc.register(str_acc, "string_length_accumulator")
# 测试数据
data = sc.parallelize(["apple", "banana", "cherry", "date", "elderberry"])
# 使用累加器
data.foreach(lambda s: str_acc.add(s))
# 获取结果
total_length, count = str_acc.value
print(f"总字符串数量: {count}") # 输出: 总字符串数量: 5
print(f"字符串总长度: {total_length}") # 输出: 字符串总长度: 25
print(f"平均字符串长度: {total_length / count}") # 输出: 平均字符串长度: 5.0
spark.stop()累加器使用注意事项
-
不要在 Transformation 中读取累加器值 ：
Transformation 是惰性执行的，且可能被多次计算，在其中读取累加器值会得到不可靠的结果。
-
累加器更新可能被重复执行 ：
当任务失败重试时，Spark 会重新执行任务，导致累加器被多次更新。不过 Spark 内部会处理这种情况，确保每个任务的更新只被计算一次。
-
累加器不应用于控制流 ：
不要根据累加器的值来决定程序的执行路径，因为在 Transformation 中无法获取到正确的累加器值。
-
累加器性能考量 ：
频繁更新累加器会产生网络开销，因为每个更新都需要与 Driver 通信。对于性能敏感的场景，应批量更新或考虑其他方案。
-
累加器与广播变量的区别：
- 累加器：从 Executor 到 Driver 的单向数据聚合
- 广播变量：从 Driver 到 Executor 的只读数据分发
合理使用累加器可以简化分布式计算中的状态聚合操作，尤其是在需要统计、计数或收集特定数据时，能显著提高代码的简洁性和效率。