def runJob[T, U](      rdd: RDD[T],      func: (TaskContext, Iterator[T]) => U,      partitions: Seq[Int],      callSite: CallSite,      resultHandler: (Int, U) => Unit,      properties: Properties): Unit = {    //生成运行job的启动时间    val start = System.nanoTime    //提交job,submitJob是异步执行的，所以会立刻返回JobWaiter对象    val waiter = submitJob(rdd, func, partitions, callSite, resultHandler, properties)    //等待job处理，如果成功打印日志，如果失败打印日志并抛出异常    ThreadUtils.awaitReady(waiter.completionFuture, Duration.Inf)    waiter.completionFuture.value.get match {      case scala.util.Success(_) =>        logInfo("Job %d finished: %s, took %f s".format          (waiter.jobId, callSite.shortForm, (System.nanoTime - start) / 1e9))      case scala.util.Failure(exception) =>        logInfo("Job %d failed: %s, took %f s".format          (waiter.jobId, callSite.shortForm, (System.nanoTime - start) / 1e9))        // SPARK-8644: Include user stack trace in exceptions coming from DAGScheduler.        val callerStackTrace = Thread.currentThread().getStackTrace.tail        exception.setStackTrace(exception.getStackTrace ++ callerStackTrace)        throw exception    }  }

def submitJob[T, U](      rdd: RDD[T],      func: (TaskContext, Iterator[T]) => U,      partitions: Seq[Int],      callSite: CallSite,      resultHandler: (Int, U) => Unit,      properties: Properties): JobWaiter[U] = {    // Check to make sure we are not launching a task on a partition that does not exist.    //获取当前job的最大分区数并检查，如果有不存在的分区则抛出异常    val maxPartitions = rdd.partitions.length    partitions.find(p => p >= maxPartitions || p < 0).foreach { p =>      throw new IllegalArgumentException(        "Attempting to access a non-existent partition: " + p + ". " +          "Total number of partitions: " + maxPartitions)    }    //生成下一个job的ID    val jobId = nextJobId.getAndIncrement()    //如果job的分区数为0，创建一个totalTasks属性为0的JobWaiter并返回，JobWaiter会将jobPromise设置为Success表示job处理成功    if (partitions.size == 0) {      // Return immediately if the job is running 0 tasks      return new JobWaiter[U](this, jobId, 0, resultHandler)    }    //如果job的分区数大于0，创建一个等待执行完成的JobWaiter，向DAGSchedulerEventProcessLoop发送JobSubmited事件    assert(partitions.size > 0)    val func2 = func.asInstanceOf[(TaskContext, Iterator[_]) => _]    val waiter = new JobWaiter(this, jobId, partitions.size, resultHandler)    eventProcessLoop.post(JobSubmitted(      jobId, rdd, func2, partitions.toArray, callSite, waiter,      SerializationUtils.clone(properties)))    //返回JobWaiter对象    waiter  }

private[scheduler] def handleJobSubmitted(jobId: Int,      finalRDD: RDD[_],      func: (TaskContext, Iterator[_]) => _,      partitions: Array[Int],      callSite: CallSite,      listener: JobListener,      properties: Properties) {    var finalStage: ResultStage = null    //创建ResultStage，期间可能会发生异常，比如运行在HadoopRDD上的任务依赖的HDFS文件被删除了，异常发生时需要调用JobWaiter的jobFailed方法    try {      finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite)    } catch {      ...    }        // Job submitted, clear internal data.    barrierJobIdToNumTasksCheckFailures.remove(jobId)    //创建ActiveJob    val job = new ActiveJob(jobId, finalStage, callSite, listener, properties)    //清除cacheLocs缓存中RDD的分区位置信息    clearCacheLocs()    logInfo("Got job %s (%s) with %d output partitions".format(      job.jobId, callSite.shortForm, partitions.length))    logInfo("Final stage: " + finalStage + " (" + finalStage.name + ")")    logInfo("Parents of final stage: " + finalStage.parents)    logInfo("Missing parents: " + getMissingParentStages(finalStage))        //生成job提交的时间    val jobSubmissionTime = clock.getTimeMillis()    //将jobID与刚创建的activeJob之间的对应关系放入jobIdToActiveJob中    jobIdToActiveJob(jobId) = job    //将刚创建的activeJob放入activeJobs集合    activeJobs += job    //让finalStage的_activeJob属性持有刚创建的activeJob    finalStage.setActiveJob(job)    //获取当前job的所有stage对应的stageinfo    val stageIds = jobIdToStageIds(jobId).toArray    val stageInfos = stageIds.flatMap(id => stageIdToStage.get(id).map(_.latestInfo))    //向LiveListenerBus投递sparkListenerJobStart事件，缓存stageId    listenerBus.post(      SparkListenerJobStart(job.jobId, jobSubmissionTime, stageInfos, properties))    //提交ResultStage    submitStage(finalStage)  }

private def createResultStage(      rdd: RDD[_],      func: (TaskContext, Iterator[_]) => _,      partitions: Array[Int],      jobId: Int,      callSite: CallSite): ResultStage = {    //RDD的一些初始检查    checkBarrierStageWithDynamicAllocation(rdd)    checkBarrierStageWithNumSlots(rdd)    checkBarrierStageWithRDDChainPattern(rdd, partitions.toSet.size)    //获取所有父stage的列表    val parents = getOrCreateParentStages(rdd, jobId)    //生成resultStage的标识    val id = nextStageId.getAndIncrement()    //创建ResultStage    val stage = new ResultStage(id, rdd, func, partitions, parents, jobId, callSite)    //将ResultStage与它的ID对应关系添加到stageIdToStage缓存中    stageIdToStage(id) = stage    //更新job的身份标识与ResultStage的映射关系    updateJobIdStageIdMaps(jobId, stage)    stage  }  //获取或创建给定RDD的所有父stage，这些stage将被分配给jobId对应的jobprivate def getOrCreateParentStages(rdd: RDD[_], firstJobId: Int): List[Stage] = {    getShuffleDependencies(rdd).map { shuffleDep =>      getOrCreateShuffleMapStage(shuffleDep, firstJobId)    }.toList  }  //获取给定RDD直接父类的shuffle依赖private[scheduler] def getShuffleDependencies(      rdd: RDD[_]): HashSet[ShuffleDependency[_, _, _]] = {    val parents = new HashSet[ShuffleDependency[_, _, _]]    val visited = new HashSet[RDD[_]]    val waitingForVisit = new ArrayStack[RDD[_]]    waitingForVisit.push(rdd)    while (waitingForVisit.nonEmpty) {      val toVisit = waitingForVisit.pop()      if (!visited(toVisit)) {        visited += toVisit        toVisit.dependencies.foreach {          case shuffleDep: ShuffleDependency[_, _, _] =>            parents += shuffleDep          case dependency =>            waitingForVisit.push(dependency.rdd)        }      }    }    parents  }  private def getOrCreateShuffleMapStage(      shuffleDep: ShuffleDependency[_, _, _],      firstJobId: Int): ShuffleMapStage = {    shuffleIdToMapStage.get(shuffleDep.shuffleId) match {        //如果已经创建了shullfeDependecy对应的shullfeMapStage，则直接返回shullfeMapStage      case Some(stage) =>        stage        //否则调用getMissingAncestorShuffleDependencies找到所有未创建shuffleMapStage的shullfeDependecy        //并调用createShuffleMapStage创建shullfeMapStage并注册      case None =>        getMissingAncestorShuffleDependencies(shuffleDep.rdd).foreach { dep =>          if (!shuffleIdToMapStage.contains(dep.shuffleId)) {            createShuffleMapStage(dep, firstJobId)          }        }        // 最后为当前shullfeDependecy创建shullfeMapStage并注册        createShuffleMapStage(shuffleDep, firstJobId)    }  } private def getMissingAncestorShuffleDependencies(      rdd: RDD[_]): ArrayStack[ShuffleDependency[_, _, _]] = {    val ancestors = new ArrayStack[ShuffleDependency[_, _, _]]    val visited = new HashSet[RDD[_]]    // We are manually maintaining a stack here to prevent StackOverflowError    // caused by recursively visiting    val waitingForVisit = new ArrayStack[RDD[_]]    waitingForVisit.push(rdd)    while (waitingForVisit.nonEmpty) {      val toVisit = waitingForVisit.pop()      if (!visited(toVisit)) {        visited += toVisit        getShuffleDependencies(toVisit).foreach { shuffleDep =>          if (!shuffleIdToMapStage.contains(shuffleDep.shuffleId)) {            ancestors.push(shuffleDep)            waitingForVisit.push(shuffleDep.rdd)          } // Otherwise, the dependency and its ancestors have already been registered.        }      }    }    ancestors  }def createShuffleMapStage(shuffleDep: ShuffleDependency[_, _, _], jobId: Int): ShuffleMapStage = {    //获取shuffleDependecy的rdd属性作为将要创建shuffleMapStage的rdd    val rdd = shuffleDep.rdd    //rdd初始检查    checkBarrierStageWithDynamicAllocation(rdd)    checkBarrierStageWithNumSlots(rdd)    checkBarrierStageWithRDDChainPattern(rdd, rdd.getNumPartitions)    //获取rdd的分区数组的长度作为要创建的shullfeMapStage的task的数量    val numTasks = rdd.partitions.length    //获取将要创建的shullfeMapStage的所有父stage    val parents = getOrCreateParentStages(rdd, jobId)    //生成将要创建的shullfeMapStage的身份标识    val id = nextStageId.getAndIncrement()    //创建shullfeMapStage    val stage = new ShuffleMapStage(      id, rdd, numTasks, parents, jobId, rdd.creationSite, shuffleDep, mapOutputTracker)    //更新刚创建的shuffleMapStage的映射关系    stageIdToStage(id) = stage    shuffleIdToMapStage(shuffleDep.shuffleId) = stage    updateJobIdStageIdMaps(jobId, stage)    //mapStatus的检查，因为stage可以重试，所以当前stage可能已经执行过，有部分map任务可能执行成功并将mapStatus更新到    //mapOutputTrackerMaster的缓存，当前stage只要复制这些mapStatus即可，避免重复计算    if (!mapOutputTracker.containsShuffle(shuffleDep.shuffleId)) {      // Kind of ugly: need to register RDDs with the cache and map output tracker here      // since we can't do it in the RDD constructor because # of partitions is unknown      logInfo("Registering RDD " + rdd.id + " (" + rdd.getCreationSite + ")")      mapOutputTracker.registerShuffle(shuffleDep.shuffleId, rdd.partitions.length)    }    stage  }

private def submitStage(stage: Stage) {    //获取当前stage对应的jobId    val jobId = activeJobForStage(stage)    //判断获取到的jobId是否能找到对应的ActiveJob    if (jobId.isDefined) {      logDebug("submitStage(" + stage + ")")      //如果当前stage还未提交      if (!waitingStages(stage) && !runningStages(stage) && !failedStages(stage)) {        //获取当前stage的所有未提交的父stage        val missing = getMissingParentStages(stage).sortBy(_.id)        logDebug("missing: " + missing)        //如果没有未提交的父stage，就提交当前stage中所有未提交的task；否则先提交所有未提交的fustage，并将当前stage加入waitingSrages集合        if (missing.isEmpty) {          logInfo("Submitting " + stage + " (" + stage.rdd + "), which has no missing parents")          submitMissingTasks(stage, jobId.get)        } else {          for (parent <- missing) {            submitStage(parent)          }          waitingStages += stage        }      }    } else {  //如果没有找到当前stage对应的ActiveJob，终止依赖于当前stage的所有Job      abortStage(stage, "No active job for stage " + stage.id, None)    }  }