RDD 的成员之一是依赖集，依赖集也关系到任务调度

源码

Dependency代码主要在一个源文件中：core/Dependency代码中有5个类。
除此以外在 core/rdd/PartitionPruningRDD还有一个PruneDependency类。
他们的名称和继承关系如下图：

3017B56B-EBD0-4E3A-BAD8-777B872194D4.png

通过阅读代码可以得到以下信息：

1. 依赖的根类是Dependency，只有一个RDD 成员，表示依赖的对象。这类继承了Serializable类，是可以序列化的。

2. 依赖分为两大种，一个叫窄依赖(Narrow)，另一个就洗牌依赖(Shuffle，很多材料也叫作“宽”依赖)。

3. 从数量关系上说，“1-to-1”(OneToOne)、“n-to-1”(Range)、“1-to-部分分区”(Prune，剪枝)是窄依赖，宽依赖是“n-to-n”的。

4. “1-to-1”是RDD的默认依赖。上节中的MapPartitionRDD是一对一的转换，就包含“1-to-1“依赖。

5. ”n-to-1“的依赖只有一个使用场景——UnionRDD，“交”运算，多个 RDD 合并到一个 RDD 中。

6. 剪枝依赖是个私有对象，用于优化，减少数据载入。

7. 洗牌依赖复杂一些。

只有 RDD 的转换（Transformations）才用到依赖，RDD 的操作（Actions，如reduce、collect等）就不需要依赖，直接运行SparkContext.runjob()函数。RDD 有哪些转换和操作？阅读文档： Spark Programming Guide - Spark 2.0.2 Documentation

洗牌依赖

洗牌依赖也只是相对复杂，代码也不长。

@DeveloperApiclass 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]] {

  override def rdd: RDD[Product2[K, V]] = _rdd.asInstanceOf[RDD[Product2[K, V]]]  private[spark] val keyClassName: String = reflect.classTag[K].runtimeClass.getName  private[spark] val valueClassName: String = reflect.classTag[V].runtimeClass.getName  // Note: It's possible that the combiner class tag is null, if the combineByKey
  // methods in PairRDDFunctions are used instead of combineByKeyWithClassTag.
  private[spark] val combinerClassName: Option[String] = Option(reflect.classTag[C]).map(_.runtimeClass.getName)

  val shuffleId: Int = _rdd.context.newShuffleId()

  val shuffleHandle: ShuffleHandle = _rdd.context.env.shuffleManager.registerShuffle(shuffleId, _rdd.partitions.length, this)
  _rdd.sparkContext.cleaner.foreach(_.registerShuffleForCleanup(this))
}

是的，只有8行代码，核心内容是：

1. 这个类有三个泛型类型，K=key，V=value，C=combiner；

2. 洗牌依赖只能用于Product2[K, V]及其父类，即 KV 数据；

3. 成员有 分区器(partitioner) 、序列器(serializer)、排序器(keyOrdering)、聚合器(aggregator)、map 端聚合开关(mapSideCombine)；

4. _rdd.context.newShuffleId() 获得一个自增的 ID；

5. _rdd.context.env.shuffleManager.registerShuffle 获得几个洗牌的句柄。通过core/shuffle/sort/SortShuffleManager代码可以知道，一共有三种句柄：

   1. 分区数很少（小于变量spark.shuffle.sort.bypassMergeThreshold，默认200）时，用BypassMergeSortShuffleHandle，直接发送数据合并，不用耗时的序列化和反序列化；

   2. 否则，如果能序列化，则用SerializedShuffleHandle，用序列化和反序列化，降低网络 IO；

   3. 否则，使用基础的BaseShuffleHandle。

Scala语法

在 Java 中使用null 是非常容易出错的，在 Guava( GitHub - google/guava: Google Core Libraries for Java 6+ ) 中提供了 Optional 来避免使用 null。
同样的 Scala 自带了 Option 来避免使用 null。

Option 有两个子类，Some 和 None

scala> val capitals = Map("France"->"Paris", "Japan"->"Tokyo", "China"->"Beijing")
capitals: scala.collection.immutable.Map[String,String] = Map(France -> Paris, Japan -> Tokyo, China -> Beijing)

scala> capitals get "France"res0: Option[String] = Some(Paris)

scala> capitals get "North Pole"res1: Option[String] = None

None.get 会报错，用 getOrElse 可以给取不到值的时候赋默认值：

scala> capitals get "North Pole" get
warning: there was one feature warning; re-run with -feature for details
java.util.NoSuchElementException: None.get
  at scala.None$.get(Option.scala:347)
  at scala.None$.get(Option.scala:345)
  ... 33 elided

scala> capitals get "France" get
warning: there was one feature warning; re-run with -feature for details
res3: String = Paris

scala> (capitals get "North Pole") getOrElse "Oops"res7: String = Oops

scala> capitals get "France" getOrElse "Oops"res8: String = Paris

在 Spark 中大量使用了 Option。

疑问列表

我将阅读过程中的未解内容记录下来，留待以后阅读代码时解答。疑问一个一个划掉，就是成长的过程。

1. reduce 等 RDD 操作是如何执行的？

2. groupByKey 等洗牌操作是如何执行的？不同的洗牌类型有什么用？

结论

1. 在 RDD 的转换时，会用到依赖

2. 依赖包括窄依赖（1-to-1、n-to-1关系）、洗牌依赖（n-to-n 关系）

3. 洗牌依赖包含分区器、序列器、排序器、聚合器、map聚合开关、ID、洗牌类型句柄等成分组成。洗牌类型句柄有三种。

@ Kangying Village, Beijing, China

Spark源码/Dependency

作者：泥菩萨酱
链接：https://www.jianshu.com/p/64ade88f0e19