RDD 依赖关系

 RDD 血缘关系

        RDD不会保存数据的，RDD为了提供容错性，需要将RDD间的关系保存下来，一旦出现错误，可以根据血缘关采将数据源重新读取进行计算。

package com.atguigu.bigdata.spark.core.rdd.dep

import org.apache.spark.{SparkConf, SparkContext}

object Spark01_RDD_Dep {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sc = new SparkContext(sparkConf)

    val lines = sc.textFile("data/word.txt")
    println(lines.toDebugString)
    println("==================================")

    val words = lines.flatMap(_.split(" "))
    println(words.toDebugString)
    println("==================================")

    val wordtoOne=words.map{
      word =>(word,1)
    }
    println(wordtoOne.toDebugString)
    println("==================================")

    val wordcount = wordtoOne.reduceByKey(_ + _)
    println(wordcount.toDebugString)
    println("==================================")

    val array = wordcount.collect()
    array.foreach(println)
    sc.stop()
  }

}

运行结果： 

 RDD 依赖关系

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

val sparkConf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sc = new SparkContext(sparkConf)

    val lines = sc.textFile("data/word.txt")
    println(lines.dependencies)
    println("==================================")

    val words = lines.flatMap(_.split(" "))
    println(words.dependencies)
    println("==================================")

    val wordtoOne=words.map{
      word =>(word,1)
    }
    println(wordtoOne.dependencies)
    println("==================================")

    val wordcount = wordtoOne.reduceByKey(_ + _)
    println(wordcount.dependencies)
    println("==================================")

    val array = wordcount.collect()
    array.foreach(println)
    sc.stop()

RDD 窄依赖

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

class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd)

 

窄依赖不存在阶段划分。

RDD 宽依赖

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

class ShuffleDependency[K: ClassTag, V: ClassTag, C: ClassTag](
 @transient private val _rdd: RDD[_ <: Product2[K, V]],
 val partitioner: Partitioner,
 val serializer: Serializer = SparkEnv.get.serializer,
 val keyOrdering: Option[Ordering[K]] = None,
 val aggregator: Option[Aggregator[K, V, C]] = None,
 val mapSideCombine: Boolean = false)
 extends Dependency[Product2[K, V]] 

 宽依赖会存在阶段划分，也就是前一个阶段所有的Task要执行完毕，才能进行下一个阶段。

 RDD 任务划分

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

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

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