持久化

RDD Cache缓存

RDD 通过 Cache 或者 Persist 方法将前面的计算结果缓存,默认情况下会把数据以缓存在 JVM 的堆内存中。但是并不是这两个方法被调用时立即缓存,而是触发后面的 action 算子时,该 RDD 将会被缓存在计算节点的内存中,并供后面重用。

// cache 操作会增加血缘关系,不改变原有的血缘关系
println(wordToOneRdd.toDebugString)
// 数据缓存。
wordToOneRdd.cache()
// 可以更改存储级别
//mapRdd.persist(StorageLevel.MEMORY_AND_DISK_2)

存储级别

object StorageLevel {
 val NONE = new StorageLevel(false, false, false, false)
 val DISK_ONLY = new StorageLevel(true, false, false, false)
 val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2)
 val MEMORY_ONLY = new StorageLevel(false, true, false, true)
 val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
 val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false)
 val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)
 val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)
 val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
 val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
 val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
 val OFF_HEAP = new StorageLevel(true, true, true, false, 1)

【Spark】Spark扩展_spark
缓存有可能丢失,或者存储于内存的数据由于内存不足而被删除,RDD 的缓存容错机制保证了即使缓存丢失也能保证计算的正确执行。通过基于 RDD 的一系列转换,丢失的数据会被重算,由于 RDD 的各个 Partition 是相对独立的,因此只需要计算丢失的部分即可,并不需要重算全部 Partition。

Spark 会自动对一些 Shuffle 操作的中间数据做持久化操作(比如:reduceByKey)。这样做的目的是为了当一个节点 Shuffle 失败了避免重新计算整个输入。但是,在实际使用的时候,如果想重用数据,仍然建议调用 persist 或 cache。

跳转顶部


RDD CheckPoint 检查点

所谓的检查点其实就是通过将 RDD 中间结果写入磁盘

由于血缘依赖过长会造成容错成本过高,这样就不如在中间阶段做检查点容错,如果检查点
之后有节点出现问题,可以从检查点开始重做血缘,减少了开销。

对 RDD 进行 checkpoint 操作并不会马上被执行,必须执行 Action 操作才能触发。


// 设置检查点路径
sc.setCheckpointDir("./checkpoint1")
// 创建一个 RDD,读取指定位置文件:hello atguigu atguigu
val lineRdd: RDD[String] = sc.textFile("input/1.txt")
// 业务逻辑
val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" "))
val wordToOneRdd: RDD[(String, Long)] = wordRdd.map {
 word => {
 (word, System.currentTimeMillis())
 }
}
// 增加缓存,避免再重新跑一个 job 做 checkpoint
wordToOneRdd.cache()
// 数据检查点:针对 wordToOneRdd 做检查点计算
wordToOneRdd.checkpoint()
// 触发执行逻辑
wordToOneRdd.collect().foreach(println)

跳转顶部


缓存和检查点区别

Cache 缓存只是将数据保存起来,不切断血缘依赖。Checkpoint 检查点切断血缘依赖。

Cache 缓存的数据通常存储在磁盘、内存等地方,可靠性低。Checkpoint 的数据通常存储在 HDFS 等容错、高可用的文件系统,可靠性高。

建议对 checkpoint()的 RDD 使用 Cache 缓存,这样 checkpoint 的 job 只需从 Cache 缓存
中读取数据即可,否则需要再从头计算一次 RDD。

跳转顶部


自定义分区

我们可以通过自定义分区来实现将数据以文件的形式来保存,将具有相同特性的文件保存在指定的文件中
具体步骤

  • 新建一个类继承Partitioner
  • 重写numPartitions方法,此方法是定义分区的数量;
  • 重写getPartition方法,此方法是定义分区的规则,按照数据的key返回数据的分区索引(从0开始)

问题描述:将数据中key相同的数据放入一个文件

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

/**
 * 分区器的实现
 */
object partitionTest01 {
  def main(args: Array[String]): Unit = {
    val spark = new SparkConf().setMaster("local[*]").setAppName("Partition")
    val sc = new SparkContext(spark)
    sc.setLogLevel("ERROR")

    val rdd = sc.makeRDD(List(
      ("NBA", "OOOOOOOO"),
      ("CBA", "XXXXXXXX"),
      ("WNBA", "LLLLLLLL"),
      ("NBA", "ZZZZZZZZ")
    ), 3)
    val partRDD = rdd.partitionBy(new MyPartition)
    partRDD.saveAsTextFile("output")
    sc.stop()
  }

  /**
   * 自定义分区器
   * 1.继承Partitioner
   * 2.重写方法
   */
  class MyPartition extends Partitioner {
    //分区数量
    override def numPartitions: Int = 3

    //按照数据的key返回数据的分区索引(从0开始)
    override def getPartition(key: Any): Int = {
      key match {
        case "NBA" => 0
        case "WNBA" => 1
        case _ => 2
      }
    }
  }
}

结果展示
【Spark】Spark扩展_数据_02
跳转顶部


存储与读取

三种数据存储方式

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

object IOTest {
  def main(args: Array[String]): Unit = {
    val spark = new SparkConf().setMaster("local[*]").setAppName("IO")
    val sc = new SparkContext(spark)
    sc.setLogLevel("ERROR")
    val rdd = sc.makeRDD(List(
      ("a",1),
      ("b",2),
      ("c",3)
    ))
    //三种存储方式
    rdd.saveAsTextFile("output")
    rdd.saveAsObjectFile("output2")
    rdd.saveAsSequenceFile("output3")
  }
}
  • SequenceFile文件是 Hadoop 用来存储二进制形式的key-value对而设计的一种平面文件(Flat File)。在 SparkContext 中,可以调用 sequenceFile[keyClass, valueClass](path)
  • 对象文件是将对象序列化后保存的文件,采用 Java 的序列化机制。可以通过 objectFile[T: ClassTag](path)函数接收一个路径,读取对象文件,返回对应的 RDD,也可以通过调用saveAsObjectFile()实现对对象文件的输出。因为是序列化所以要指定类型。

读取三种文件

    //读取txt文件
    val rdd1 = sc.textFile("output")
    println(rdd1.collect().mkString(","))
    //读取object文件
    val rdd2 = sc.objectFile[(String,Int)]("output2")
    println(rdd2.collect().mkString(","))
    //读取Sequence文件
    val rdd3 = sc.sequenceFile[String,Int]("output3")
    println(rdd3.collect().mkString(","))

结果展示
【Spark】Spark扩展_scala_03
跳转顶部


累加器

问:如何将List(1,2,3,4)求和?

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

object account {
  def main(args: Array[String]): Unit = {
    val spark = new SparkConf().setMaster("local[*]").setAppName("ACC")
    val sc = new SparkContext(spark)
    sc.setLogLevel("ERROR")

    val rdd = sc.makeRDD(List(1, 2, 3, 4))

    //若要求和有几种方式?
    //这种方法可行,但是太过于繁琐了
    val count = rdd.reduce(_ + _)
    println(count)

    /**
     * 在处理数据时,driver将数据(包含sum)发布到executor,
     * 每一个一个executor分别处理各自的数据,但是没有方法将结果数据发送到driver进行汇总处理
     */
    var sum = 0
    rdd.foreach(
      num => (sum += num)
    )
    println(sum)

    sc.stop()
  }
}

使用foreach的图解如下
【Spark】Spark扩展_缓存_04


累加器实现原理:累加器用来把 Executor 端变量信息聚合到 Driver 端。在 Driver 程序中定义的变量,在Executor 端的每个 Task 都会得到这个变量的一份新的副本,每个 task 更新这些副本的值后,传回 Driver 端进行 merge。

图解
【Spark】Spark扩展_数据_05


系统累加器

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

object accountTest02 {
  def main(args: Array[String]): Unit = {
    val spark = new SparkConf().setMaster("local[*]").setAppName("account")
    val sc = new SparkContext(spark)
    sc.setLogLevel("ERROR")

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    //获取系统累加器
    val sumAcc = sc.longAccumulator("sum")
    rdd.foreach(
      num => sumAcc.add(num)
    )
    //获取累加器
    println(sumAcc.value)
    sc.stop()
  }
}

累加器一般放在行动算子中执行,否则会出现多加或者少加的情况


自定义累加器
使用自定义累加器实现WordCount

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

import scala.collection.mutable

object accountTest03 {
  def main(args: Array[String]): Unit = {
    val spark = new SparkConf().setMaster("local[*]").setAppName("accountTest03")
    val sc = new SparkContext(spark)
    sc.setLogLevel("ERROR")

    val rdd = sc.makeRDD(List("hadoop", "flume", "scala", "hadoop"))

    //创建累加器对象
    val wcAcc = new MyAccumulator
    //向Spark进行注册
    sc.register(wcAcc, "wordCountAcc")

    rdd.foreach(
      word => wcAcc.add(word)
    )

    //获取累加器的结果
    println(wcAcc.value)
    sc.stop()
  }

  /**
   * 1.继承AccumulatorV2,并且定义泛型
   * IN:累加器输入的数据类型
   * OUT:累加器返回的数据类型
   * 2.实现方法
   */
  class MyAccumulator extends AccumulatorV2[String, mutable.Map[String, Long]] {
    //定义属性
    private var wcMap = mutable.Map[String, Long]()

    //判断是否为初始状态
    override def isZero: Boolean = {
      wcMap.isEmpty
    }

    override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = {
      new MyAccumulator()
    }

    //重置累加器(清空)
    override def reset(): Unit = {
      wcMap.clear()
    }

    //获取累加器需要计算的值
    override def add(v: String): Unit = {
      //通过v也就是输入的word去查看value(词频次数),如果找到了就在原基础上加一,没有就是0加一
      val newCnt = wcMap.getOrElse(v, 0l) + 1
      //更新value的值
      wcMap.update(v, newCnt)
    }

    /** Driver合并累加器
     * 实际上就是两个累加器的输出结果的合并,也就是wcMap
     * 为什么会有两个累加器?两个executor的输出结果到driver合并
     */
    override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
      val map1 = this.wcMap
      val map2 = other.value

      map2.foreach {
        case (word, count) => {
          val newCount = map1.getOrElse(word, 0l) + count
          map1.update(word, newCount)
        }
      }
    }

    //返回累加器结果
    override def value: mutable.Map[String, Long] = {
      wcMap
    }
  }
}

结果展示
【Spark】Spark扩展_spark_06
注意

  • 自定义累加器要继承AccumulatorV2
  • 继承时还要注意泛型,即输入数据的类型和输出数据的类型
  • 继承后实现AccumulatorV2的方法
  • spark在使用自定义累加器时需要先生产一个对象再注册
    跳转顶部

广播

广播就是一个分布式共享只读变量

广播变量用来高效分发较大的对象。向所有工作节点发送一个较大的只读值,以供一个或多个 Spark 操作使用。比如,如果你的应用需要向所有节点发送一个较大的只读查询表,广播变量用起来都很顺手。在多个并行操作中使用同一个变量,但是 Spark 会为每个任务分别发送。

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

import scala.collection.mutable

object bctest01 {
  def main(args: Array[String]): Unit = {
    val spark = new SparkConf().setMaster("local[*]").setAppName("bc")
    val sc = new SparkContext(spark)
    sc.setLogLevel("ERROR")
    val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))

    val rdd2 = sc.makeRDD(List(("a", 4), ("b", 5), ("c", 6)))

    //将两个RDD联合
    //join会导致数据量的几何倍增长,并且会影响shuffle的性能,不推荐使用
    //rdd1.join(rdd2).collect().foreach(println(_))
    //不使用join该如何实现rdd的联合呢?
    val map = mutable.Map(("a", 4), ("b", 5), ("c", 6))
    rdd1.map{
      case (w,c) =>{
        val l = map.getOrElse(w, 0l)
        (w,(c,l))
      }
    }

    //使用广播
    //封装广播变量
    val bc: Broadcast[mutable.Map[String, Int]] = sc.broadcast(map)
    //使用广播来取值
    rdd1.map{
      case (w,c) =>{
        //访问
        val l = bc.value.getOrElse(w, 0l)
        (w,(c,l))
      }
    }.collect().foreach(println(_))
    sc.stop()
  }
}

结果展示
【Spark】Spark扩展_java_07
图解
【Spark】Spark扩展_缓存_08
注意:

  • 闭包数据,都是以Task为单位发送的,每个任务中包含闭包数据,这样可能会导致,一个Executor中含有大量重复的数据,并且占用大量的内存
  • Executor其实就一个JVM,所以在启动时,会自动分配内存,完全可以将任务中的闭包数据放置在Executor的内存中,达到共享的目的
  • Spark中的广播变量就可以将闭包的数据保存到Executor的内存中
  • Spark中的广播变量不能够更改 : 分布式共享只读变量

跳转顶部