java的变量累加_广播变量&累加变量

1、 广播&累加器

我们传递给Spark的函数，如map()，或者filter()的判断条件函数，能够利用定义在函数之外的变量，但是集群中的每一个task都会得到变量的一个副本，并且task在对变量进行的更新不会被返回给driver。而Spark的两种共享变量：累加器(accumulator)和广播变量(broadcast variable)，在广播和结果聚合这两种常见类型的通信模式上放宽了这种限制。 使用累加器可以很简便地对各个worker返回给driver的值进行聚合。

由于对于worker节点来说，累加器的值是不可访问的，所有对于worker上的task，累加器是write-only的。这使得累加器可以被更高效的实现，而不需要在每次更新时都进行通信。

Spark保证：在终止操作中对累加器的操作只执行一次，而转化操作中则可能多次执行。

累加器的操作可以多种，比如算术加法 MAX，只要这些操作符合交换律和结合律。

累加器会多次传递给Executor节点(而广播只一次)。

1. Accumulator

import java.util.ArrayList;

import java.util.List;

import org.apache.spark.Accumulator;

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.PairFunction;

import org.apache.spark.broadcast.Broadcast;

import scala.Tuple2;

public class AccumulatorDemo {

public static void main(String[] xx){

SparkConf conf = new SparkConf();

conf.setMaster("local[4]");

conf.setAppName("WordCounter");

conf.set("spark.default.parallelism", "4");

conf.set("spark.testing.memory", "2147480000");

JavaSparkContext ctx = new JavaSparkContext(conf);

Person[] persons = new Person[10000];

Broadcast persons_br = ctx.broadcast(persons);

Accumulator count = ctx.accumulator(0);

List data1 = new ArrayList();

data1.add("Cake");

data1.add("Bread");

data1.add("");

data1.add("Cheese");

data1.add("Milk");

data1.add("Toast");

data1.add("Bread");

data1.add("");

data1.add("Egg");

data1.add("");

JavaRDD rdd1 = ctx.parallelize(data1, 2);

System.out.println(rdd1.glom().collect());

rdd1.mapToPair(new PairFunction() {

@Override

public Tuple2 call(String s) throws Exception {

long id = Thread.currentThread().getId();

System.out.println("s:" + s + " in thread:" + id);

if(s.equals("")){

count.add(1);

}

return new Tuple2(s, 1);

}

}).collect();

System.out.println(count.value());

rdd1.mapToPair(new PairFunction() {

@Override

public Tuple2 call(String s) throws Exception {

long id = Thread.currentThread().getId();

System.out.println("s:" + s + " in thread:" + id);

if(s.equals("")){

count.add(1);

// System.out.println("c:"+count.value());

}

System.out.println(persons_br.value().length);

return new Tuple2(s, 1);

}

}).collect();

System.out.println(count.value());

ctx.stop();

}

}

class Person{}

2.BroadCast

import java.util.Arrays;

import java.util.List;

import org.apache.spark.Accumulator;

import org.apache.spark.SparkConf;

import org.apache.spark.api.java.JavaPairRDD;

import org.apache.spark.api.java.function.Function;

import org.apache.spark.api.java.function.Function2;

import org.apache.spark.api.java.function.PairFunction;

import org.apache.spark.broadcast.Broadcast;

import org.apache.spark.streaming.Durations;

import org.apache.spark.streaming.Time;

import org.apache.spark.streaming.api.java.JavaPairDStream;

import org.apache.spark.streaming.api.java.JavaReceiverInputDStream;

import org.apache.spark.streaming.api.java.JavaStreamingContext;

import scala.Tuple2;

/**

* 实例：利用广播进行黑名单过滤！ 检查新的数据 根据是否在广播变量-黑名单内，从而实现过滤数据。

*/

public class BroadCastDemo {

/**

* 创建一个List的广播变量

*

*/

private static volatile Broadcast> broadcastList = null;

/**

* 计数器！

*/

private static volatile Accumulator accumulator = null;

public static void main(String[] args) {

SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("WordCountOnlineBroadcast");

conf.set("spark.testing.memory", "2147480000");

JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));

/**

* 注意：分发广播需要一个action操作触发。 注意：广播的是Arrays的asList

* 而非对象的引用。广播Array数组的对象引用会出错。 使用broadcast广播黑名单到每个Executor中！

*/

broadcastList = jsc.sparkContext().broadcast(Arrays.asList("Hadoop", "Mahout", "Hive"));

/**

* 累加器作为全局计数器！用于统计在线过滤了多少个黑名单！ 在这里实例化。

*/

accumulator = jsc.sparkContext().accumulator(0, "OnlineBlackListCounter");

JavaReceiverInputDStream lines = jsc.socketTextStream("Master", 9999);

/**

* 这里省去flatmap因为名单是一个个的！

*/

JavaPairDStream pairs = lines.mapToPair(new PairFunction() {

@Override

public Tuple2 call(String word) {

return new Tuple2(word, 1);

}

});

JavaPairDStream wordsCount = pairs.reduceByKey(new Function2() {

@Override

public Integer call(Integer v1, Integer v2) {

return v1 + v2;

}

});

/**

* Funtion里面 前几个参数是 入参。 后面的出参。 体现在call方法里面！

*

*/

//wordsCount.foreach(new Function2,Time,boolean>() {

//@Override

//public boolean call(JavaPairRDD rdd, Time time) throws Exception {

//rdd.filter(new Function, Boolean>() {

//@Override

//public Boolean call(Tuple2 wordPair) throws Exception {

//if (broadcastList.value().contains(wordPair._1)) {

///**

// * accumulator不仅仅用来计数。 可以同时写进数据库或者缓存中。

// */

//accumulator.add(wordPair._2);

//return false;

//} else {

//return true;

//}

//};

///**

// * 广播和计数器的执行，需要进行一个action操作！

// */

//}).collect();

//System.out.println("广播器里面的值" + broadcastList.value());

//System.out.println("计时器里面的值" + accumulator.value());

//return null;

//}

//});

jsc.start();

try {

jsc.awaitTermination();

} catch (InterruptedException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

}

jsc.close();

}

}