RDD持久化
1. RDD Cache 缓存
说明
RDD 通过Cache 或者Persist 方法将前面的计算结果缓存，默认情况下会把数据以缓存在JVM 的堆内存中。但是并不是这两个方法被调用时立即缓存，而是触发后面的 action 算子时，该RDD 将会被缓存在计算节点的内存中，并供后面重用。
// cache 操作会增加血缘关系，不改变原有的血缘关系
println(wordToOneRdd.toDebugString)
// 数据缓存。
wordToOneRdd.cache()
// 可以更改存储级别
//mapRdd.persist(StorageLevel.MEMORY_AND_DISK_2)
案例实操
package com.atguigu.bigdata.spark.core.rdd.Persist
import org.apache.spark.rdd.RDD
import org.apache.spark.{
SparkConf, SparkContext}
object Spark03_RDD_Persist {
def main(args: Array[String]): Unit = {
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
val list = List("Hello Spark","Hello Scala")
val rdd = sc.makeRDD(list)
val flatRDD = rdd.flatMap(_.split(" "))
val mapRDD = flatRDD.map(
word => {
println("@@@@@@@@@@")
(word,1)
}
)
mapRDD.cache() ///持久化操作
val reduceRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_ + _)
reduceRDD.collect().foreach(println)
println("***************************")
val groupRDD: RDD[(String, Iterable[Int])] = mapRDD.groupByKey()
groupRDD.collect().foreach(println)
sc.stop()
}
}
存储级别
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)
缓存有可能丢失，或者存储于内存的数据由于内存不足而被删除，RDD 的缓存容错机制保证了即使缓存丢失也能保证计算的正确执行。通过基于RDD 的一系列转换，丢失的数据会被重算，由于RDD 的各个Partition 是相对独立的，因此只需要计算丢失的部分即可，并不需要重算全部Partition。
Spark 会自动对一些 Shuffle 操作的中间数据做持久化操作(比如：reduceByKey)。这样做的目的是为了当一个节点 Shuffle 失败了避免重新计算整个输入。但是，在实际使用的时候，如果想重用数据，仍然建议调用persist 或 cache。
2. RDD CheckPoint 检查点
说明
所谓的检查点其实就是通过将RDD 中间结果写入磁盘。
由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销。
对RDD 进行checkpoint 操作并不会马上被执行，必须执行Action 操作才能触发。
案例实操
package com.atguigu.bigdata.spark.core.rdd.Persist
import org.apache.spark.rdd.RDD
import org.apache.spark.{
SparkConf, SparkContext}
object Spark04_RDD_Persist {
def main(args: Array[String]): Unit = {
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
sc.setCheckpointDir("cp")
val list = List("Hello Spark","Hello Scala")
val rdd = sc.makeRDD(list)
val flatRDD = rdd.flatMap(_.split(" "))
val mapRDD = flatRDD.map(
word => {
println("@@@@@@@@@@")
(word,1)
}
)
//checkpoint需要落盘，需要指定检查点保存的路径
//检查点保存的文件，作业执行完，不会删除
//一般的保存路径都是在分布式存储系统中，HDFS
mapRDD.checkpoint()
val reduceRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_ + _)
reduceRDD.collect().foreach(println)
println("***************************")
val groupRDD: RDD[(String, Iterable[Int])] = mapRDD.groupByKey()
groupRDD.collect().foreach(println)
sc.stop()
}
}
3. 缓存和检查点区别
（1）Cache 缓存只是将数据临时保存起来进行重用，不切断血缘依赖，它会在血缘关系中添加新的依赖,一旦出现问题，它可以从头读取数据。Checkpoint 检查点切断血缘依赖，会重新建立新的血缘关系，它等同于改变的数据源。同时将数据长久的保存在磁盘文件中进行数据重用。
（2）Cache 缓存的数据通常存储在磁盘、内存等地方，可靠性低。Checkpoint 的数据通常存储在HDFS 等容错、高可用的文件系统，可靠性高。
（3）建议对checkpoint () 的RDD 使用Cache 缓存，这样 checkpoint 的job 只需从 Cache 缓存
中读取数据即可，否则需要再从头计算一次RDD。
（4）persist：将数据临时存储在磁盘文件中进行数据重用，涉及到磁盘IO，性能较低，但是数据安全；如果作业执行完毕，临时保存的数据文件就会丢失。