Spark--RDD依赖关系

——>

RDD依赖于RDD1，RDD2依赖于RDD1…
相邻的两个RDD的关系称之为依赖关系
多个连续的RDD依赖关系，称之为血缘关系
每个RDD不会保存数据，但每个RDD会保存血缘关系

一. RDD血缘关系

• RDD只支持粗粒度转换，即在大量记录上执行的单个操作。将创建 RDD 的一系列Lineage （血统）记录下来，以便恢复丢失的分区。RDD的Lineage 会记录RDD 的元数据信息和转换行为，当该RDD的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区。
• RDD为了提高容错性，需要将RDD间的关系保存下来，一旦出现错误，可以根据血缘关系将数据源重新读取进行计算。

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("RDD").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd: RDD[String] = sc.textFile("datas\\2.txt")
    //打印血缘关系
    println(rdd.toDebugString)
    println("-------------")
    val flatRDD: RDD[String] = rdd.flatMap(x=>x.split(" "))
    println(flatRDD.toDebugString)
    println("-------------")
    val mapRDD: RDD[(String, Int)] = flatRDD.map((_,1))
    println(mapRDD.toDebugString)
    println("-------------")
    val reduceRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_)
    println(reduceRDD.toDebugString)
    println("-------------")
    
    sc.stop()
  }
}

(2) datas\2.txt MapPartitionsRDD[1] at textFile at Spark_rdd_01.scala:13 []
 |  datas\2.txt HadoopRDD[0] at textFile at Spark_rdd_01.scala:13 []
-------------
(2) MapPartitionsRDD[2] at flatMap at Spark_rdd_01.scala:16 []
 |  datas\2.txt MapPartitionsRDD[1] at textFile at Spark_rdd_01.scala:13 []
 |  datas\2.txt HadoopRDD[0] at textFile at Spark_rdd_01.scala:13 []
-------------
(2) MapPartitionsRDD[3] at map at Spark_rdd_01.scala:19 []
 |  MapPartitionsRDD[2] at flatMap at Spark_rdd_01.scala:16 []
 |  datas\2.txt MapPartitionsRDD[1] at textFile at Spark_rdd_01.scala:13 []
 |  datas\2.txt HadoopRDD[0] at textFile at Spark_rdd_01.scala:13 []
-------------
(2) ShuffledRDD[4] at reduceByKey at Spark_rdd_01.scala:22 []
 +-(2) MapPartitionsRDD[3] at map at Spark_rdd_01.scala:19 []
    |  MapPartitionsRDD[2] at flatMap at Spark_rdd_01.scala:16 []
    |  datas\2.txt MapPartitionsRDD[1] at textFile at Spark_rdd_01.scala:13 []
    |  datas\2.txt HadoopRDD[0] at textFile at Spark_rdd_01.scala:13 []
-------------

二. RDD依赖关系

这里所谓的依赖关系，其实就是两个相邻 RDD 之间的关系

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("RDD").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd: RDD[String] = sc.textFile("datas\\2.txt")
    //打印依赖关系
    println(rdd.dependencies)
    println("-------------")
    val flatRDD: RDD[String] = rdd.flatMap(x=>x.split(" "))
    println(flatRDD.dependencies)
    println("-------------")
    val mapRDD: RDD[(String, Int)] = flatRDD.map((_,1))
    println(mapRDD.dependencies)
    println("-------------")
    val reduceRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_)
    println(reduceRDD.dependencies)
    println("-------------")

    sc.stop()
  }
}

//新的RDD的一个分区的数据依赖于旧的RDD一个分区的数据
//这个依赖称之为OneToOne依赖
List(org.apache.spark.OneToOneDependency@6a818392)
-------------
List(org.apache.spark.OneToOneDependency@b9a77c8)
------------- 
List(org.apache.spark.OneToOneDependency@1645f294)
-------------
//新的RDD的一个分区的数据依赖于旧的RDD多个分区的数据
//这个依赖称之为Shuffle依赖
List(org.apache.spark.ShuffleDependency@5af5d76f)
-------------

三. RDD窄依赖

窄依赖表示每一个父(上游)RDD 的 Partition 最多被子（下游）RDD 的一个 Partition 使用， 窄依赖我们形象的比喻为独生子女。

四. RDD宽依赖

宽依赖表示同一个父（上游）RDD 的 Partition 被多个子（下游）RDD 的 Partition 依赖，会引起 Shuffle，总结：宽依赖我们形象的比喻为多生。

五. RDD阶段划分

DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。例如，DAG 记录了RDD 的转换过程和任务的阶段。

当RDD中存在shuffle依赖时，阶段会自动增加一个
阶段的数量=shuffle依赖的数量+1
ResultStage只有一个，最后需要执行的阶段

六. RDD任务划分

RDD 任务切分中间分为：Application、Job、Stage 和 Task

• Application：初始化一个 SparkContext 即生成一个Application；
• Job：一个Action（行动） 算子就会生成一个Job；
• Stage：Stage 等于宽依赖(ShuffleDependency)的个数加 1；
• Task：一个 Stage 阶段中，最后一个RDD 的分区个数就是Task 的个数。任务的数量=当前阶段中最后一个RDD的分区数量。

注意：Application->Job->Stage->Task 每一层都是 1 对 n 的关系。一个Application对应多个Job，一个Job对应多个Stage，一个Stage对应多个Task