- 小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。
环境
var sc:SparkContext = _
@Before
def beforeTest(): Unit ={
val sparkConf = new SparkConf().setMaster("local").setAppName("wc")
sc = new SparkContext(sparkConf)
}
@After
def afterTest(): Unit ={
sc.stop()
}
未持久化
@Test
def cache{
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map(word=>{
println("******")
(word,1)
})
val wordCount: RDD[(String, Int)] = wordOne.reduceByKey(_+_)
wordCount.collect().foreach(println)
val group: RDD[(String, Iterable[Int])] = wordOne.groupByKey()
group.collect().foreach(println)
}
结果：
******
******
******
******
(Spark,1)
(Hello,2)
(Scala,1)
******
******
******
******
(Spark,CompactBuffer(1))
(Hello,CompactBuffer(1, 1))
(Scala,CompactBuffer(1))
结论：虽然我们都是对wordOne进行算子操作，但是从结果可以看出来，/******/输出两遍，执行collect算子时都是从开始执行了一遍所有依赖的算子
Cache/Persist 缓存
-
RDD 通过 Cache 或者 Persist 方法将前面的计算结果缓存，默认情况下会把数据以缓存在 JVM 的堆内存中。
-
但是并不是这两个方法被调用时立即缓存，而是触发后面的 action 算子时，该 RDD 将会被缓存在计算节点的内存中，并供后面重用。
//1. 数据缓存，调用的还是persist，存储级别默认为 memory
wordOne.cache()
//2. 可以更改存储级别
wordOne.persist(StorageLevel.DISK_ONLY)
- 结果：
******
******
******
******
(Spark,1)
(Hello,2)
(Scala,1)
(Spark,CompactBuffer(1))
(Hello,CompactBuffer(1, 1))
(Scala,CompactBuffer(1))
Tips：
- 存储级别
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。
CheckPoint 检查点
-
将 RDD 中间结果写入磁盘。
-
由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销。
-
对 RDD 进行 checkpoint 操作并不会马上被执行，必须执行 Action 操作才能触发。
代码调整
@Test
def cache{
sc.setCheckpointDir("cp")
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map(word=>{
println("******")
(word,1)
})
// 增加缓存,避免再重新跑一个 job 做 checkpoint
wordOne.cache()
// 数据检查点：针对 wordToOneRdd 做检查点计算
wordOne.checkpoint()
val wordCount: RDD[(String, Int)] = wordOne.reduceByKey(_+_)
// 触发执行逻辑
wordCount.collect().foreach(println)
val group: RDD[(String, Iterable[Int])] = wordOne.groupByKey()
group.collect().foreach(println)
}
结果：
cache、persist、checkpoint小结
cache
- 优点：将数据临时存储在内存中进行数据重用，会在血缘关系中添加新的依赖，一旦出现问题，可以重头读取数据。
- 缺点：数据量大会造成OOM。
persist
- 优点: 将数据临时存储在磁盘文件中进行数据重用涉及到磁盘IO，性能较低，但是数据安全。
- 缺点：如果作业执行完毕，临时保存的数据文件就会丢失。
checkpoint
- 优点: 将数据长久地保存在磁盘文件中进行数据重用涉及到磁盘IO，性能较低，但是数据安全。
- 缺点：为了保证数据安全，会独立执行作业。
- 优化：为了能够提高效率，一般情况下，是需要和cache联合使用。
- tips：执行过程中，会切断血缘关系，重新建立新的血缘关系，checkpoint等同于改变数据源。
