CacheTest

package com.bjsxt.scala.spark.test

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.storage.StorageLevel

object CacheTest {
  def main(args: Array[String]): Unit = {
    
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("CacheTest")
    
    
    val sc = new SparkContext(conf)
    var rdd = sc.textFile("d:/wc.txt")
    
    /**
     * 第一个job计算的数据依然来源于磁盘
     * cache是persist的一个简化版
     * rdd.persist(StorageLevel.MEMORY_ONLY) = rdd.cache()
     * DISK_ONLY:将RDD的数据持久化到磁盘上
     * MEMORY_ONLY：:将RDD的数据持久化到内存上
     * DISK_ONLY_2:将RDD的数据持久化到磁盘上，并且有两个备份  数据更安全了
     * MEMORY_ONLY_2：将RDD的数据持久化到内存上，并且有两个备份  数据更安全了
     * MEMORY_ONLY_SER：将数据进行序列化后在保存到内存中，更节省内存了，但是在使用数据的时候要进行反序列化，消耗cpu资源
     * MEMORY_ONLY_SER_2：将数据进行序列化后在保存到内存中，并且有两个备份
     * MEMORY_AND_DISK：将RDD的数据先往内存中存储，如果内存不足在写入到磁盘上，并不是内存一份磁盘一份
     * MEMORY_AND_DISK_2：....
     * MEMORY_AND_DISK_SER:将数据进行序列化后先往内存中存储，如果内存不足在写入到磁盘上
     * 
     * 问题1：如果选用cache算子，内存不足怎么办？
     * 		内存不足，数据直接丢失，不会出现OO没问题
     * 问题2：如果数据在进行吃计划的时候，数据丢失了，会不会有计算不准的问题？
     * 		不会！！！，因为RDD是由依赖关系的，数据丢了，可以基于父RDD重新计算过来
     * 问题3：在持久化的时候如果选用的持久化级别是MEMORY_AND_DISK，RDD中一个partition的计算结果是否可能保存到内存一部分，磁盘一部分呢？
     * 		没有，持久化的单位是partition的计算结果，这个partition的数据要么全部保存到内存，要么全部保存到磁盘
     */
    rdd = rdd.persist(StorageLevel.DISK_ONLY_2)
    val statTime = System.currentTimeMillis()
    val count = rdd.count()
    val endtime = System.currentTimeMillis()
    println("durations:" + (endtime-statTime) + "\tresult:" + count)
    
    /**
     *  第二个job计算的数据依然来源于内存
     */
    val statTime1 = System.currentTimeMillis()
    val count1 = rdd.count()
    val endtime1 = System.currentTimeMillis()
    println("durations:" + (endtime1-statTime1) + "\tresult:" + count1)
    
    sc.stop()          
  }
}