Spark 学习笔记----共享变量

最新推荐文章于 2024-02-10 16:56:22 发布

PZ~浪味仙

最新推荐文章于 2024-02-10 16:56:22 发布

阅读量473

点赞数

分类专栏： Spark

Spark 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

一、共享变量工作原理

Spark一个非常重要的特性就是共享变量。
默认情况下，如果在一个算子的函数中使用的到了某个外部变量，那么这个变量的值会被拷贝到每个task中。此时每个task只能操作自己的那份变量副本。如果多个task想要共享某个变量，那么这种方式是无法做到的。
Spark为此提供了两种共享变量。一种是Broadcast Variable（广播变量），另一种是Accumulator（累加变量）。

Broadcast Variable会将使用到的变量，仅仅为每个节点拷贝一份，更大的用处是优化性能，减少网络传输以及内存消耗。
Accumulator则可以让多个task共同操作一份变量，主要可以进行累加操作。

默认情况下，算子的函数内，使用到的外部变量，会拷贝到执行这个函数的每个task中。
如果那个变量特别大的话，则网络传输会特别大，而且在每个节点上，占用的内存空间也会特别大。
如果将算子的函数使用到的变量，做成共享变量，那么每个变量，只会拷贝一份到每个节点上，节点上所有的task都会共享这一份变量。

二、共享变量详解

1、Broadcast Variable（广播变量)

Spark提供的Broadcast Variable，是只读的。并且在每个节点上只会有一份副本，而不会为每个task都拷贝一份副本。因此其最大作用就是减少变量到各个节点的网络传输消耗，以及在各个节点上的内存消耗。此外，spark自己内部也使用了高效的广播算法来减少网络消耗。

可以通过调用SparkContext的broadcast()方法，来针对某个变量创建广播变量。然后再算子的函数内，使用到广播变量时，每个节点只会拷贝一份副本了。每个节点可以使用广播变量的value()方法来获取值。

注意：广播变量是只读的。

实战：

java版本

public class BroadcastVariable_java {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("BroadcastVariable").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);
        //在Java中创建共享变量，就是调用SparkContext的broadcast()方法
        //获取的返回结果是Broadcast<T>类型
        final int factor = 3;
        //将factor做成共享变量，每个节点只拷贝一份
        final Broadcast<Integer> factorBroadcast = sc.broadcast(factor);
        
        List<Integer> numberList = Arrays.asList(1,2,3,4,5);
        JavaRDD<Integer> numbers = sc.parallelize(numberList);

        //让集合中的每个数字都乘以外部定义的那个factor
        JavaRDD<Integer> multipleNumbers = numbers.map(new Function<Integer, Integer>() {
            public Integer call(Integer v1) throws Exception {
                //获取共享变量
                //使用共享变量时，调用其value()方法，即可获取其内部的封装的值
                int factor = factorBroadcast.value();
                return v1 * factor;
            }
        });
        multipleNumbers.foreach(new VoidFunction<Integer>() {
            public void call(Integer t) throws Exception {
                System.out.println(t);
            }
        });

    }
}

scala版本

object BroadcastVariable_scala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("BroadcastVariable_scala").setMaster("local")

    val sc = new SparkContext(conf)

    val factor = 3
    val factorBroadcast = sc.broadcast(factor)

    val numberArray = Array(1,2,3,4,5)
    val numbers = sc.parallelize(numberArray,1)

    val multipleNumber = numbers.map{num => num * factorBroadcast.value}

    multipleNumber.foreach(num => println(num))

  }
}

2、Accumulator(累加器)

Spark提供的Accumulator，主要用于多个节点对一个变量进行共享性的操作。Accumulator值提供了累加的功能，但是却给我们提供了多个task对一个变量并行操作功能。但是task只能对Accumulator进行累加操作，不能读取它的值。只有Driver程序可以读取Accumulator的值。

实战：

java版本

public class Accumulator_java {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("Accumulator_java").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        //创建Accumulator变量
        //需要调用SparkContext的accumulator()方法
        final Accumulator<Integer> sum = sc.accumulator(0);
        List<Integer> numberList = Arrays.asList(1,2,3,4,5);

        JavaRDD<Integer> numbers = sc.parallelize(numberList);

        numbers.foreach(new VoidFunction<Integer>() {
            public void call(Integer t) throws Exception {
                //然后在函数内部，就可以对Accumulator变量，调用add()方法，累加值
                sum.add(t);
            }
        });

        //在driver程序中，可以调用Accumulator的value()方法，获取其值
        System.out.println(sum.value());

        sc.close();
    }

}

scala版本

object Accumulator_scala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Accumulator_scala").setMaster("local")
    val sc  = new SparkContext(conf)

    val sum = sc.accumulator(0);

    val numberArray = Array(1,2,3,4,5)
    val numbers = sc.parallelize(numberArray)

    numbers.foreach( num => sum += num)
    println(sum)
  }
}