Spark之累加器

一、系统累加器

        累加器：分布式共享只写变量。（Executor和Executor之间不能读数据）

        累加器用来把Executor端变量信息聚合到Driver端。在Driver中定义的一个变量，在Executor端的每个task都会得到这个变量的一份新的副本，每个task更新这些副本的值后，传回Driver端进行合并计算。

定义：SparkContext.accumulator(initialValue)方法

object accumulator01_system {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf()
          .setAppName("WC")
          .setMaster("local[*]")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("a", 2), ("a", 3), ("a", 4)))

    val sum: LongAccumulator = sc.longAccumulator("sum")

    dataRDD.foreach{
      case (word,count) => {
        sum.add(count)
      }
    }

    println(("a",sum.value))
    sc.stop()
  }
}

注意：

        Executor端的任务不能读取累加器的值（例如：在Executor端调用sum.value，获取的值不是累加器最终的值）。因此我们说，累加器是一个分布式共享只写变量。

        累加器要放在行动算子中，因为转换算子执行的次数取决于job的数量，如果一个spark应用有多个行动算子，那么转换算子中的累加器可能会发生不止一次更新，导致结果错误。所以，如果想要一个无论在失败还是重复计算时都绝对可靠的累加器，我们必须把它放在foreach()这样的行动算子中。

对于在行动算子中使用的累加器，Spark只会把每个Job对各累加器的修改应用一次。

二、自定义累加器

自定义累加器步骤

（1）继承AccumulatorV2，设定输入、输出泛型

（2）重写6个抽象方法

（3）使用自定义累加器需要注册：sc.register(累加器,"累加器名字")

object accumulator03_define {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf()
          .setAppName("WC")
          .setMaster("local[*]")
    val sc: SparkContext = new SparkContext(conf)
    val rdd: RDD[String] = sc.makeRDD(List("Hello", "Hello", "Hello", "Hello", "Spark", "Spark","Hive","Hive"), 2)

    //创建累加器
    val acc: myaccumulator = new myaccumulator()
    //注册累加器
    sc.register(acc,"wordcount")
    //使用累加器
    rdd.foreach{
      word => {
        acc.add(word)
      }
    }
    //获取累加器的累加结果
    println(acc.value)
    sc.stop()
  }
}

class myaccumulator extends AccumulatorV2[String,mutable.Map[String,Long]]{
  // 定义输出数据集合,一个可变的Map
  var map: mutable.Map[String, Long] = mutable.Map[String,Long]()
  // 是否为初始化状态，如果集合数据为空，即为初始化状态
  override def isZero: Boolean = map.isEmpty
  // 复制累加器
  override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = new myaccumulator()
  // 重置累加器
  override def reset(): Unit = map.clear()
  // 增加数据
  override def add(v: String): Unit = {
    if(v.startsWith("H")){
      map(v) = map.getOrElse(v,0L) + 1
    }
  }
  // 合并累加器
  override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
    val map2: mutable.Map[String, Long] = other.value
    map2.foreach{
      case (word,count) =>{
        map(word) = map.getOrElse(word,0L) + count
      }
    }

  }
  //累加器的值
  override def value: mutable.Map[String, Long] = map
}