内核进阶_宽窄依赖关系

这里所谓的依赖关系，其实就是两个相邻RDD之间的关系，分为以下两种：

1. 窄依赖表示每一个父(上游)RDD的Partition最多被子（下游）RDD的一个Partition使用。

   

2. 宽依赖表示同一个父（上游）RDD的Partition被多个子（下游）RDD的Partition依赖，会引起Shuffle。

   

   xxxxxxxxxx
   package com.itbaizhan.core
   
   //1.导入spark下的SparkConf, SparkContext
   import org.apache.spark.rdd.RDD
   import org.apache.spark.{SparkConf, SparkContext}
   
   object DependencyDemo {
     def main(args: Array[String]): Unit = {
       //2.构建SparkConf对象，并设置本地运行和程序的名称
       val conf = new SparkConf().setMaster("local[*]").setAppName("Lineage")
       //3.通过SparkConf对象构建SparkContext对象
       val sc = new SparkContext(conf)
       //4.读取文件
       val fileRdd:RDD[String] = sc.textFile("hdfs://mycluster/wordcount/input/wc.txt")
       println("--------------00--------------")
       //显示依赖关系OneToOneDependency extends NarrowDependency
       println(fileRdd.dependencies)
       //5.将单词进行切割, 得到一个存储全部单词的集合对象
       val wordsRdd:RDD[String] = fileRdd.flatMap(_.split(" "))
       println("--------------11--------------")
       //显示依赖关系OneToOneDependency
       println(wordsRdd.dependencies)
       //6.将单词转换为元组对象, key是单词, value是数字1
       val wordAndOneRdd:RDD[(String,Int)] = wordsRdd.map((_, 1))
       println("--------------22--------------")
       //显示依赖关系OneToOneDependency
       println(wordAndOneRdd.dependencies)
       //7.将元组的value 按照key来分组, 对所有的value执行聚合操作(相加)
       val resultRdd:RDD[(String,Int)] = wordAndOneRdd.reduceByKey(_+_)
       println("--------------33--------------")
       //显示依赖关系ShuffleDependency 宽依赖
       println(resultRdd.dependencies)
       //8.通过collect方法收集RDD的数据
       val wordCount: Array[(String, Int)] = resultRdd.collect()
       //9.打印输出结果
       wordCount.foreach(println)
     }
   }
   

实时效果反馈

1. 关于宽窄依赖关系的描述，错误的是：

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

B 窄依赖表示父(上游)RDD的每一个分区最多被子（下游）RDD的一个分区使用。

C 宽依赖表示父（上游）RDD的同一个Partition被多个子（下游）RDD的Partition依赖，会引起Shuffle。

D reduceByKey前后的两个RDD之间是窄依赖关系。

答案：

1=>D 宽依赖关系