Spark06： 共享变量（广播变量、累加变量）

一、共享变量的工作原理

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());
    }
}