Spark作业执行原理（二）——划分调度阶段
Spark调度阶段的划分是由DAGScheduler实现，DAGScheduler会从最后一个RDD出发，根据RDD的lineage使用广度优先算法遍历整个依赖树（总共使用了两次，一次是遍历区分ResultStage范围；另一次则是遍历获取ShuffleMapStage划分依据，用来划分每个ShuffleMapStage范围），从而划分调度阶段，调度阶段的划分依据是以是否进行shuffle操作进行的。
真正的stage划分代码，是从handleJobSubmitted方法中根据最后一个RDD实例化ResultStage对象开始，实例化过程中，finalRDD使用getParentStages找出其依赖的祖先RDD是否存在Shuffle操作，如果没有存在Shuffle操作，则本次作业只有一个ResultStage；如果存在Shuffle操作，则本次作业除了一个ResultStage之外，还至少一个ShuffleMapStage。
handleJobSubmitted部分源码：
private[scheduler] def handleJobSubmitted(jobId:Int, finalRDD:RDD[_], func:(TaskContext, Iterator[_]) => _, partitions:Array[Int], callSite:CallSite, listener:JobListener, properties:Properties){
//定义一个ResultStage类型对象,用于存储DAG划分出来的最后一个Stage
val finalStage:ResultStage = null
try{
finalStage = new ResultStage(finalRDD, func, partitions, jobId, callSite)
}catch{...}
//根据最后一个阶段生成作业
val job = new ActiveJob(jobId, finalStage, callSite, listener, properties)
clearCacheLocs()
...
//提交作业
submitStage(finalStage)
submitWaitingStages()
}
上面代码在实例化ResultStage时，传入了一个finalRDD，其实这个finalRDD会被传到getParentStagesAndId的方法中，在该方法中调用getParentStages，生成最后一个调度阶段finalStage（这里第一次使用广度优先算法）。
private def getParentStages(rdd:RDD[_], firstJobId:Int):List[Stage] = {
val parents = new HashSet[Stage] // parents是一个元素类型为Stage的HashSet集合
val visited = new HashSet[RDD[_]] //用于存放已经访问过的RDD
//存放非ShuffleDependency的RDD
val waitingForVisit = new Stack[RDD[_]]
//广度优先遍历，根据当前所依赖的RDD类型，进行不同的操作
def visit(r:RDD[_]){
if(!visited(r)){
visited += r //将当前RDD标记为已访问，即存放到visited的HashSet集合里面
for (dep <- r.dependencies){
//当前RDD所依赖的父RDD类型为ShuffleDepedency时，需要向前遍历，获取ShuffleMapStage
case shufDep:ShuffleDependency[_, _, _] =>
parents += getShuffleMapStage(shufDep, firstJobId)
case _ =>
waitingForVisit.push(dep.rdd)
}
}
}
waitingFoVisit.push(rdd)
//开始遍历Stack中的rdd
while(waitingForVisit.nonEmpty){
visit(waitingForVisit.pop())
}
parents.toList //返回parents
}
上面代码显示，如果当前遍历的RDD，其所依赖的父RDD的类型是ShuffleDependency类型时，需要往前遍历，找出所有ShuffleMapStage（或者说找出所有划分ShuffleMapStage的依据——RDD），该算法也是用到了广度优先遍历算法，跟getParentStage类似，具体由getAncestorShuffleDependencies方法实现。
getAncestorShuffleDependencies方法部分源码：
private def getAncestorShuffleDependencies(rdd:RDD[_]):Stack[ShuffleDependency[_, _, _]] = {
val parents = new Stack[ShuffleDependency[_, _, _]]
val visited = new HashSet[RDD[_]]
//用于存放非ShuffleDependency类型的RDD
val waitingForVisit = new Stack[RDD[_]]
def visit(r:RDD[_]){
if(!visited(r)){
visited += r //标记当前rdd已经被访问过，即加入visited 中
for(dep <- r.dependencies){
case shufDep:ShuffleDependency[_, _, _] =>
if(!shuffleToMapStage.contains(shufDep.shuffleId)){
parents.push(shufDep) //shuffle依据放进Stack中
}
case _ => //不操作
}
}
}
//向前遍历依赖树，获取所有的类型为ShuffleDependency的RDD，作为划分阶段的依据
waitingForVisit.push(rdd)
while(waitingForVisit.nonEmpty){
visit(waitingForVisit.pop())
}
parents //返回parents
}
getAncestorShuffleDependencies方法其实只是找出了ShuffleDependency类型的RDD，而这些RDD就是划分各个ShuffleMapStage的依据。
当所有阶段的划分操作完成后，这些阶段就会建立起依赖关系。该依赖关系是通过调度阶段属性parents:List[Stage]来定义，通过该属性可以获取当前阶段所有祖先阶段，可以根据这些信息按顺序提交调度阶段进行运行。
下面是一张Spark调度阶段的Stage划分图：
Spark调度阶段Stage划分流程：
- 在SparkContext中触发提交作业时，会调用DAGScheduler的handleJobSubmitted方法，在该方法中会先找到最后一个RDD（即RDD7），并调用getParentStages方法；
- 在getParentStages方法中判断RDD7所依赖的父RDD是否存在Shuffle操作，上图RDD6属于ShuffleDepedency类型，则对RDD6进行下一步操作；
- 通过getAncestorShuffleDependencies方法，对RDD6进行向前遍历，寻找所有的划分依据，向前遍历，发现只有RDD4，所以RDD3->RDD4被划分成一个ShuffleMapStage0，RDD5->RDD6被划分成ShuffleMapStage1；
- 最后，剩下的生成ResultStage2，一共3个阶段，在提交阶段按顺序运行。
