概述
作业（Job）
调度阶段（stage）
任务（Task）
DAGScheduler：面向调度阶段的任务调节器，负责接收spark应用提交的作业，根据RDD的依赖关系（根据宽依赖划分）划分调度阶段，并提交stage给TaskScheduler。
TaskScheduler：面向任务的调度器，接收DAGScheduler提交过来的stage，然后以stage划分后的结果，将Task分发到Work节点运行，有Worker节点的Exectuor来运行该任务。
Spark中对RDD的操作算子主要分为转换操作和行动操作，对于转换操作是lazy级别的，也就是延迟执行，只有出现了行动操作才出发了作业的提交。
1、Job由DAGScheduler划分成多个stage
2、stage由TaskScheduler划分成多个Task
3、每个TaskScheduler只为一个SparkContext实例服务，TaskScheduler接收来自DAGScheduler过来的任务集，把任务集以任务的形式一个一个分发到集群Worker节点的Executor中去运行。如果某个任务运行失败，TaskScheduler要负责重试，如果发现其中一个任务一直为运行完，就可能启动同样的任务，哪个先运行完就用哪个结果。
4、Worker中的Executor收到TaskScheduler发送的任务后，以多线程的方式运行，每一个线程负责一个任务，运行结束后要返回给TaskScheduler，不同类型的任务，返回的方式也不同，shuffleMapTask返回的是一个MapsStatus对象，而不是结果本身，ResultTask根据大小的冉，返回方式也可分为两类。
5、下图展示了作业和任务调度方法之间的调用关系，在类之间既有直接调用，也有通过RPC远程调用，在途中使用了虚线箭头进行标记的即为远程调用。
分段
提交作业
因为转换操作是延迟执行，所以作业真正提交是从"count"这个行动操作出现开始的，在RDD的源码中，count方法触发了SparkContext的runJob方法来提交作业，这部分是由内部隐形调用runJob，不需要用户显性的去提交作业。
对于RDD，会根据依赖关系形成一个有向无环图（DAG），然后把DAG交给DAGScheduler来处理。SparkContext的runJob方法经过几次调用后，进入DAGScheduler的runJob方法，其中DAGScheduler的runJob方法如下:
/**
* Run an action job on the given RDD and pass all the results to the resultHandler function as
* they arrive.
*
* @param rdd target RDD to run tasks on
* @param func a function to run on each partition of the RDD
* @param partitions set of partitions to run on; some jobs may not want to compute on all
* partitions of the target RDD, e.g. for operations like first()
* @param callSite where in the user program this job was called
* @param resultHandler callback to pass each result to
* @param properties scheduler properties to attach to this job, e.g. fair scheduler pool name
*
* @throws Exception when the job fails
*/
def runJob[T, U](
rdd: RDD[T],
func: (TaskContext, Iterator[T]) => U,
partitions: Seq[Int],
callSite: CallSite,
resultHandler: (Int, U) => Unit,
properties: Properties): Unit = {
val start = System.nanoTime
val waiter = submitJob(rdd, func, partitions, callSite, resultHandler, properties)
// Note: Do not call Await.ready(future) because that calls `scala.concurrent.blocking`,
// which causes concurrent SQL executions to fail if a fork-join pool is used. Note that
// due to idiosyncrasies in Scala, `awaitPermission` is not actually used anywhere so it's
// safe to pass in null here. For more detail, see SPARK-13747.
val awaitPermission = null.asInstanceOf[scala.concurrent.CanAwait]
waiter.completionFuture.ready(Duration.Inf)(awaitPermission)
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
}
}
DAGScheduler会进行一系列的方法调用：
1、在runJob中调用submitJob方法来继续提交作业，这里会发生阻塞，直到作业返回结果，成功或者失败。
2、在submitJob中创建了JobWaiter对象，借助内部消息处理机制，把该对象传送给内置对象DAGSchedulerEventProcessLoop进行处理
3、在DAGSchedulerEventProcessLoop消息接收方法OnReceive中，接收到Jobsumitted样例完成模式匹配后，继续调用DAGScheduler的handleJobSubmitted中方法来提交作业，在该方法中将进行划分阶段。