一个job的生命历程
dagScheduler.runJob //（1）
--> submitJob ( eventProcessLoop.post(JobSubmitted,***) //（2）
--> eventProcessLoop //（3）
--> onReceive(event: DAGSchedulerEvent) //（4）
--> doOnReceive(event: DAGSchedulerEvent) //（5）
--> case JobSubmitted //（6）
--> dagScheduler.handleJobSubmitted //（7）
--> finalStage =createResultStage(finalRDD, func, partitions, jobId, callSite) //（8）
--> job = new ActiveJob(jobId, finalStage, callSite, listener, properties) //（9）
--> jobIdToActiveJob(jobId) = job //（10）
--> activeJobs += job //（11）
--> finalStage.setActiveJob(job) //（12）
--> stageIds = jobIdToStageIds(jobId).toArray //（13）
--> stageInfos = stageIds.flatMap(id => stageIdToStage.get(id).map(_.latestInfo)) //（14）
--> listenerBus.post(SparkListenerJobStart(job.jobId, jobSubmissionTime, stageInfos, properties)) //（15）
--> submitStage(finalStage) //（16）
--> getMissingParentStages(stage).sortBy(_.id) //（17）
--> finalStage = getOrCreateShuffleMapStage(dependency, jobId) //（18）
--> createShuffleMapStage(dep, firstJobId) //（19）
-->stage = new ShuffleMapStage(id, rdd, numTasks, parents, jobId, rdd.creationSite, shuffleDep)
--> job = new ActiveJob(jobId, finalStage, callSite, listener, properties) //（20）
--> submitStage(finalStage) //（21）//划分和提交stage算法精髓
--> submitMissingTasks(stage, jobId.get) //（22）
--> submitWaitingChildStages(stage) //(23)
--> markMapStageJobAsFinished(job, mapOutputTracker.getStatistics(dependency)) //（24）
（1）所有的action算子都会触发一个job的调度，经过多次不同的runjob重载后停在这里调度 submitJob
（2）调用eventProcessLoop方法，并发送 JobSubmitted 消息给DAGSchedulerEventProcessLoop(DAGScheduler的循环响应函数体)
（3）eventProcessLoop = new DAGSchedulerEventProcessLoop(this)
（4）onReceive 函数是接受 DAGSchedulerEventProcessLoop DAG调度程序的事件接受函数
（5）doOnReceive 实际是步骤4的事件处理函数
（6）根据步骤2的发送事件，触发 JobSubmitted 这个事件响应
（7）dagScheduler 的核心入口
（8）使用触发的job的最后一个RDD创建一个 finalstage，并且放入内存缓存中 stageIdToStage
（9）使用 finalStage 创建一个job。这个job最后一个stage就是final stage
（10）（11）（12）（13）（14）（15）把 job 加入各种内存缓存中，其实就是各个数据结构
（16）提交finalStage。总是从最后开始往前推测。
（17）获取当前stage的父stage。stage的划分算法，主要在这里。waitingForVisit = new Stack[RDD[_]]。栈结构，从最后的stage往前的stage 放进栈中，实现先进后出。符合程序调用顺序。
（18）获取最后一个stage，finalstage
（19）生成一个 ShuffleMapStage
（20）利用finalestage 生成一个job
（21）划分和提交stage算法精髓，划分好stage之后全部放在waiting stage 数据结构中
（22）提交所有在 waiting stage 中的stage，从stage0...finalstage
（23）检查等待的阶段，现在有资格重新提交。提交依赖于给定父级阶段的阶段。当父阶段完成时调用成功
（24）所有的stage划分完并提交结束
------------------------------------------------------------------------------
stage划分算法非常重要，精通spark，必须对stage划分算法很清晰，知道自己编写的spark程序被划分为几个job，每个job被划分为几个stage，
每个stage包含了哪些代码，只有知道每个stage包括哪些代码后。在线上，如果发现某个stage执行特别慢，或者某个stage一直报错，才能针对
特定的stage包含的代码排查问题，或性能调优。
stage划分算法总结：
1.从finalstage倒推（通过 栈 数据结构实现）
2.通过宽依赖，进行stage的划分
3.通过递归，优先提交父stage
------------------------------------------------------------------------------
/**
* 获取某个stage的父stage
* 对于一个stage，如果它的最后一个RDD的所有依赖都是窄依赖，将不会创建新的stage
* 如果其RDD会依赖某个RDD，用宽依赖的RDD创建一个新的stage，并立即返回这个stage
* @type {[type]}
*/
private def getMissingParentStages(stage: Stage): List[Stage] = {
val missing = new HashSet[Stage]
val visited = new HashSet[RDD[_]]
val waitingForVisit = new Stack[RDD[_]]
def visit(rdd: RDD[_]) {
if (!visited(rdd)) {
visited += rdd
val rddHasUncachedPartitions = getCacheLocs(rdd).contains(Nil)
if (rddHasUncachedPartitions) {
//遍历RDD的依赖，对于每种具有shuffle的操作，如reduceByKey，groupByKey，countByKey，底层对应了3个RDD：
//Map
for (dep <- rdd.dependencies) {
dep match {
//如果是宽依赖
case shufDep: ShuffleDependency[_, _, _] =>
//使用宽依赖的RDD创建一个 ShuffleMapStage，并且将isShuffleMap 设置为true，
//默认最后一个stage不是shuffle不是ShuffleMapStage，但是finalstage之前所有的stage都是ShuffleMapStage
val mapStage = getOrCreateShuffleMapStage(shufDep, stage.firstJobId)
if (!mapStage.isAvailable) {
missing += mapStage
}
//如果是窄依赖
case narrowDep: NarrowDependency[_] =>
//将依赖的RDD放入栈中
waitingForVisit.push(narrowDep.rdd)
}
}
}
}
}
//
waitingForVisit.push(stage.rdd)
while (waitingForVisit.nonEmpty) {
//
visit(waitingForVisit.pop())
}
missing.toList
}
taskScheduler
－－＞taskSchedulerImpl （standalone模式）
－－＞SparkDeploySchedulerBackend （负责创建AppClient, 向master注册Application）
在TaskSchedulerImpl中,对一个单独的taskset的任务进行调度.这个类负责追踪每一个taskset,如果task失败的话
会负责重试spark,直到超过重试次数,并且会通知延迟调度,为这个taskSet处理本地化机制.它的主要接口是
resourceOffer,在这个接口中,taskset会希望在一个节点上运行一个任务,并且接受任务的状态改变消息,
来知道它负责的task的状态改变了.
override def submitTasks(taskSet: TaskSet) {
val tasks = taskSet.tasks //获取ttaskSet的task列表
logInfo("Adding task set " + taskSet.id + " with " + tasks.length + " tasks")
this.synchronized {
//每个taskSet都会创建一个manager，用于管理每个taskSet，并设定最大失败次数 maxTaskFailures
val manager = createTaskSetManager(taskSet, maxTaskFailures)
val stage = taskSet.stageId
//尝试连接task，如果task失败，会负责重试spark,直到超过重试次数,并且会通知延迟调度
val stageTaskSets =
taskSetsByStageIdAndAttempt.getOrElseUpdate(stage, new HashMap[Int, TaskSetManager])
//通过 manager 获得活着的taskSet
stageTaskSets(taskSet.stageAttemptId) = manager
val conflictingTaskSet = stageTaskSets.exists { case (_, ts) =>
ts.taskSet != taskSet && !ts.isZombie
}
if (conflictingTaskSet) {
throw new IllegalStateException(s"more than one active taskSet for stage $stage:" +
s" ${stageTaskSets.toSeq.map{_._2.taskSet.id}.mkString(",")}")
}
//利用已选择的调度器schedulableBuilder，把一个taskSet的manager加入调度管理池中
/*
def initialize(backend: SchedulerBackend) {
this.backend = backend
schedulableBuilder = {
schedulingMode match {
case SchedulingMode.FIFO =>
new FIFOSchedulableBuilder(rootPool)
case SchedulingMode.FAIR =>
new FairSchedulableBuilder(rootPool, conf)
case _ =>
throw new IllegalArgumentException(s"Unsupported $SCHEDULER_MODE_PROPERTY: " +
s"$schedulingMode")
}
}
schedulableBuilder.buildPools()
}*/
schedulableBuilder.addTaskSetManager(manager, manager.taskSet.properties)
if (!isLocal && !hasReceivedTask) {
starvationTimer.scheduleAtFixedRate(new TimerTask() {
override def run() {
if (!hasLaunchedTask) {
logWarning("Initial job has not accepted any resources; " +
"check your cluster UI to ensure that workers are registered " +
"and have sufficient resources")
} else {
this.cancel()
}
}
}, STARVATION_TIMEOUT_MS, STARVATION_TIMEOUT_MS)
}
hasReceivedTask = true
}
/**
* 创建 taskScheduler 的时候,就是为 taskSchedulerImpl 创建一个 SparkDeploySchedulerBackend .
* 它负责创建AppClient,向master注册Application
*/
backend.reviveOffers()
}