Spark的chche和checkpoint

最新推荐文章于 2022-07-30 18:30:14 发布

啊帅和和。

最新推荐文章于 2022-07-30 18:30:14 发布

阅读量421

点赞数 1

分类专栏：大数据专栏。 Spark专栏。文章标签： spark 大数据 big data

本文链接：https://blog.csdn.net/l_dsj/article/details/121274112

版权

大数据专栏。同时被 2 个专栏收录

50 篇文章 1 订阅

订阅专栏

Spark专栏。

17 篇文章 0 订阅

订阅专栏

为了引入这两个机制，这里我们手写一个实现Pi的操作，这里我们只需要求出落在圆里的点与落在正方形里面的点的概率比值即可
在这里插入图片描述
这里我们着重突出
slices表示生成多少个任务
cnt表示每一个任务内生成多少个点
这里的任务数，我们每一次计算都会创建一个任务task，这就导致需要处理的文件数量非常多，这里我们就可以适当的减少slices的数量，增加cnt的数量，来提高计算效率；虽然要计算的点的数量是一样的，但是效率是完全不一样的

def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Demo6Pi")
    val sc = new SparkContext(conf)

    //这是0-1之间的随机数
//    println(Random.nextDouble())

    //slices表示生成多少个任务，cnt表示每个任务内生成多少个点
    val slices = 100
    val cnt = 10000

//parallelize 支持传入一个参数numSlices，默认是同并行度一致，可以手动指定，表示最后生成的RDD分区数是多少
    //最终会决定task的数量
    val seqRDD: RDD[Int] = sc.parallelize(0 to cnt*slices,slices)

    //这里随机生成N个[-1,1]之间的点
    val pointRDD: RDD[(Double, Double)] = seqRDD.map(seq => {
      val x: Double = Random.nextDouble() * 2 - 1
      val y: Double = Random.nextDouble() * 2 - 1
      (x, y)
    })

    //从这些点中过滤出圆内的点
    val circlePointNum: Long = pointRDD.filter(
      (kv) => {
        val x: Double = kv._1
        val y: Double = kv._2
        val res: Double = x * x + y * y
        res <= 1
      }
    ).count()

    println(circlePointNum)
    val pi: Double = circlePointNum.toDouble/ (cnt * slices) * 4
    println(pi)

  }

cache->提升效率

我们的缓存是缓存到Executor中，这里面有CPU，有内存，程序也是在Executor中运行的

为什么要使用cache

一直在我们没有加上cache缓存之前，我们所跑的spark任务和mapreduce没有什么区别，都是map和reduce，虽然在spark中归成了stage，但原理都是map和reduce，中间夹杂着shuffle

这里我们计算每个班的学生人数和总体的性别人数

val conf: SparkConf = new SparkConf()
      .setMaster("local")
      .setAppName("Demo16Cache")

    val sc: SparkContext = new SparkContext(conf)

    val stuRDD: RDD[String] = sc.textFile("D:\\BigDaTa\\JAVA_Project\\ShuJia01\\data\\students.txt")

    //统计班级人数
    stuRDD.map(line=>{
      val strings: Array[String] = line.split(",")
      (strings(4),1)
    }).reduceByKey(_+_)
      .foreach(println)

    //统计性别人数
    stuRDD.map(line=>{
      val strings: Array[String] = line.split(",")
      (strings(3),1)
    }).reduceByKey(_+_)
      .foreach(println)

我们可以发现这里面stuRDD被我们重复调用了
怎么能看出来被重复调用了呢，我们做一些小调整，对读取数据的stuRDD，我们使用一个map方法，在每次使用它的时候，我们都加上一个print

val conf: SparkConf = new SparkConf()
      .setMaster("local")
      .setAppName("Demo16Cache")

    val sc: SparkContext = new SparkContext(conf)

    val stuRDD: RDD[String] = sc.textFile("D:\\BigDaTa\\JAVA_Project\\ShuJia01\\data\\students.txt")

    val stuRDDMap: RDD[String] = stuRDD.map(stu => {
      println("stuRDD")
      stu
    })

//    stuRDDMap.cache()

    //统计班级人数
    stuRDDMap.map(line=>{
      val strings: Array[String] = line.split(",")
      (strings(4),1)
    }).reduceByKey(_+_)
      .foreach(println)

    //统计性别人数
    stuRDDMap.map(line=>{
      val strings: Array[String] = line.split(",")
      (strings(3),1)
    }).reduceByKey(_+_)
      .foreach(println)

结果我们可以发现，在两次打印数据的时候（一个学生数据，一个性别数据），都打印了”stuRDD“出来，在这里插入图片描述
所以这里我们可以发现，每一次读取数据使用的时候，都调用了两次stuRDD
每一次做计算的时候都需要重复从HDFS取数据，再加载成stuRDD，然后再拉去做计算，这样做不符合spark的计算特性
可见这篇博客
spark之所以计算速度快，就是在做计算的时候，不需要重复取数据来计算，所以这里，我们可以将数据做一个缓存，每次取这部分数使用的时候，就不需要重复从HDFS进行选取了
一份数据被取多次的时候，不需要重复读取，（重复读取的话和mapreduce没有什么区别）

在这里插入图片描述

cache缓存

被使用多次的RDD我们可以进行缓存

val conf: SparkConf = new SparkConf()
      .setMaster("local")
      .setAppName("Demo16Cache")

    val sc: SparkContext = new SparkContext(conf)

    val stuRDD: RDD[String] = sc.textFile("D:\\BigDaTa\\JAVA_Project\\ShuJia01\\data\\students.txt")

    val stuRDDMap: RDD[String] = stuRDD.map(stu => {
      println("stuRDD")
      stu
    })

    stuRDDMap.cache()

    //统计班级人数
    stuRDDMap.map(line=>{
      val strings: Array[String] = line.split(",")
      (strings(4),1)
    }).reduceByKey(_+_)
      .foreach(println)

    //统计性别人数
    stuRDDMap.map(line=>{
      val strings: Array[String] = line.split(",")
      (strings(3),1)
    }).reduceByKey(_+_)
      .foreach(println)