Spark-Core(共享变量)

Spark-Core(共享变量)

1.Shared Variables

​ 当在远程集群节点上执行传递给Spark操作（例如map或reduce）的函数时，它将在函数中使用的所有变量的单独副本上工作。这些变量将复制到每台计算机，并且远程计算机上的变量的更新不会传播回驱动程序。支持跨任务的通用，读写共享变量效率低下。但是，Spark确实为两种常见的使用模式提供了两种有限类型的共享变量：广播变量和累加器。

val value = new HashMap()
val rdd = …...
rdd.foreach(x => {
​	value…..
})

2.Accumulators(计数器/累加器)

只支持add

scala> val accum = sc.longAccumulator("My Accumulator")
accum: org.apache.spark.util.LongAccumulator = LongAccumulator(id: 0, name: Some(My Accumulator), value: 0)

scala> sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum.add(x))
...
10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s

scala> accum.value
res2: Long = 10

###3.Broadcast Variables(广播变量)

val value = new HashMap()//100M
val rdd = …...
rdd.foreach(x => {
​	value….. 1000task * 10M =10G
})

假设上边的变量的value中有10M的数据，下面的rdd有1000个task，那么在进行计算的时候就会把10M的数据发送到每个task，数据量就达到了10G，显然这种方式是不好的，那么就可以使用广播变量，Broadcast是每个机器一个副本，这个同一个机器中的task就能使用到同一个变量了，这样就可以少了很多重复的数据。

scala> val broadcastVar = sc.broadcast(Array(1, 2, 3))
broadcastVar: org.apache.spark.broadcast.Broadcast[Array[Int]] = Broadcast(0)

scala> broadcastVar.value
res0: Array[Int] = Array(1, 2, 3)

package core

import org.apache.spark.{SparkConf, SparkContext}

object BroadcastApp {

  def main(args: Array[String]): Unit = {

    val sparkConf = new SparkConf()
    sparkConf.setAppName("BroadcastApp").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)

    commonJoin(sc)
    sc.stop()
  }

  def commonJoin(sc: SparkContext) = {

    val info1 = sc.parallelize(Array(("601", "张三"), ("602", "李四")))
    val info2 = sc.parallelize(Array(("601", "东南","20"), ("603", "科大","21"), ("604", "浙大","22")))
        .map(x => (x._1,x))

    info1.join(info2).map(x =>{
      x._1 + "," + x._2._1 + "," + x._2._2._2
    }).foreach(println)

  }

}

上面是一个常规的join操作

package core

import org.apache.spark.{SparkConf, SparkContext}

object BroadcastApp {

  def main(args: Array[String]): Unit = {

    val sparkConf = new SparkConf()
    sparkConf.setAppName("BroadcastApp").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)

//    commonJoin(sc)
    broadcastJoin(sc) //使用broadcast+map代替了shuffle操作，但是小表数据进行广播的时候，数据量不能太大
    Thread.sleep(2000000)

    sc.stop()

  }

  def broadcastJoin(sc: SparkContext) = {
    //小 ==》广播
    val info1 = sc.parallelize(Array(("601", "张三"), ("602", "李四"))).collectAsMap()
    //Map(),一般采用Map的方式进行广播比较好
    val info1Broadcast = sc.broadcast(info1)
    //大
    val info2 = sc.parallelize(Array(("601", "东南","20"), ("603", "科大","21"), ("604", "浙大","22")))
      .map(x => (x._1,x))

    info2.mapPartitions(x =>{
      val broadcastMap = info1Broadcast.value
      for((key,value) <- x if (broadcastMap.contains(key)))
        //for循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。
        //Scala中for循环是有返回值的。如果被循环的是Map，返回的就是Map，被循环的是List，返回的就是List，以此类推。
        yield (key,broadcastMap.get(key).getOrElse(""),value._2)
    }).foreach(println)

  }

  def commonJoin(sc: SparkContext) = {

    val info1 = sc.parallelize(Array(("601", "张三"), ("602", "李四")))
    val info2 = sc.parallelize(Array(("601", "东南","20"), ("603", "科大","21"), ("604", "浙大","22")))
        .map(x => (x._1,x))

    info1.join(info2).map(x =>{
      x._1 + "," + x._2._1 + "," + x._2._2._2
    }).foreach(println)

  }

}

broadcast出去之后就不会再用join来实现了，大表的数据读取出来一条就和广播出去的小表的记录做匹配，这样就不会每个task一份数据，而是每台机器上一份数据，减少网络传输，减少内存消耗