SparkContext是通往Spark叢集的唯一入口，是整個Application執行排程的核心。
一、Spark Driver Program
Spark Driver Program（以下簡稱Driver）是執行Application的main函式並且新建SparkContext例項的程式。其實，初始化SparkContext是為了準備Spark應用程式的執行環境，在Spark中，由SparkContext負責與叢集進行通訊、資源的申請、任務的分配和監控等。當Worker節點中的Executor執行完畢Task後，Driver同時負責將SparkContext關閉。通常也可以使用SparkContext來代表驅動程式（Driver）。
Driver（SparkContext）整體架構圖如下所示。
二、SparkContext深度剖析
SparkContext是通往Spark叢集的唯一入口，可以用來在Spark叢集中建立RDDs、累加器（Accumulators）和廣播變數（Broadcast Variables）。SparkContext也是整個Spark應用程式（Application）中至關重要的一個物件，可以說是整個Application執行排程的核心（不是指資源排程）。
SparkContext的核心作用是初始化Spark應用程式執行所需要的核心元件，包括高層排程器（DAGScheduler）、底層排程器（TaskScheduler）和排程器的通訊終端（SchedulerBackend），同時還會負責Spark程式向Master註冊程式等。
一般而言，通常為了測試或者學習Spark開發一個Application，在Application的main方法中，最開始幾行編寫的程式碼一般是這樣的：
首先，建立SparkConf例項，設定SparkConf例項的屬性，以便覆蓋Spark預設配置檔案spark-env.sh,spark-default.sh和log4j.properties中的引數；
然後，SparkConf例項作為SparkContext類的唯一構造引數來例項化SparkContext例項物件。SparkContext在例項化的過程中會初始化DAGScheduler、TaskScheduler和SchedulerBackend，而當RDD的action觸發了作業（Job）後，SparkContext會呼叫DAGScheduler將整個Job劃分成幾個小的階段（Stage），TaskScheduler會排程每個Stage的任務（Task）進行處理。
還有，SchedulerBackend管理整個叢集中為這個當前的Application分配的計算資源，即Executor。
如果用一個車來比喻Spark Application，那麼SparkContext就是車的引擎，而SparkConf是關於引擎的配置引數。說明：只可以有一個SparkContext例項執行在一個JVM記憶體中，所以在建立新的SparkContext例項前，必須呼叫stop方法停止當前JVM唯一執行的SparkContext例項。
Spark程式在執行時分為Driver和Executor兩部分：Spark程式編寫是基於SparkContext的，具體包含兩方面。
Spark程式設計的核心基礎RDD是由SparkContext最初建立的（第一個RDD一定是由SparkContext建立的）。
Spark程式的排程優化也是基於SparkContext，首先進行排程優化。
Spark程式的註冊是通過SparkContext例項化時生產的物件來完成的（其實是SchedulerBackend來註冊程式）。
Spark程式在執行時要通過Cluster Manager獲取具體的計算資源，計算資源獲取也是通過SparkContext產生的物件來申請的（其實是SchedulerBackend來獲取計算資源的）。
SparkContext崩潰或者結束的時候，整個Spark程式也結束。
三、SparkContext原始碼解析
SparkContext是Spark應用程式的核心。我們執行WordCount程式，通過日誌來深入瞭解SparkContext。
WordCount.scala的程式碼如下。
import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.HadoopRDD import org.apache.log4j.Logger import org.apache.log4j.Level object wordcount { def main(args: Array[String]): Unit = { Logger.getLogger("org").setLevel(Level.ALL); // 第1步：建立Spark的配置物件SparkConf，設定Spark程式執行時的配置資訊， val conf = new SparkConf().setAppName("My First Spark APP").setMaster("local") // 第2步：建立SparkContext物件 val sc = new SparkContext(conf) // 第3步：根據具體的資料來源來建立RDD val lines = sc.textFile("helloSpark.txt", 1) // 第4步：對初始的RDD進行Transformation級別的處理，如通過map、filter等 val words = lines.flatMap{line=>line.split(" ")} val pairs = words.map{word=>(word,1)} pairs.cache() val wordCountsOdered = pairs.reduceByKey(_+_).saveAsTextFile("wordCountResult.log") // val wordCountsOdered = pairs.reduceByKey(_+_).map( // pair=>(pair._2,pair._1) // ).sortByKey(false).map(pair=>(pair._2,pair._1)) // wordCountsOdered.collect.foreach(wordNumberPair=>println(wordNumberPair._1+" : "+wordNumberPair._2)) // while(true){ // // } sc.stop() } }
在Eclipse中執行wordcount程式碼，日誌顯示如下：
程式一開始，日誌裡顯示的是：INFO SparkContext: Running Spark version 2.0.1，日誌中間部分是一些隨著SparkContext建立而建立的物件，另一條比較重要的日誌資訊，作業啟動了並正在執行：INFO SparkContext: Starting job: saveAsTextFile at WordCountJobRuntime.scala:58。
在程式執行的過程中會建立TaskScheduler、DAGScheduler和SchedulerBackend，它們有各自的功能。DAGScheduler是面向Job的Stage的高層排程器；TaskScheduler是底層排程器。SchedulerBackend是一個介面，根據具體的ClusterManager的不同會有不同的實現。程式列印結果後便開始結束。日誌顯示：INFO SparkContext: Successfully stopped SparkContext。
通過這個例子可以感受到Spark程式的執行到處都可以看到SparkContext的存在，我們將SparkContext作為Spark原始碼閱讀的入口，來理解Spark的所有內部機制。
我們從一個整體去看SparkContext建立的例項物件。首先，SparkContext構建的頂級三大核心為DAGScheduler、TaskScheduler、SchedulerBackend，其中，DAGScheduler是面向Job的Stage的高層排程器；TaskScheduler是一個介面，是底層排程器，根據具體的ClusterManager的不同會有不同的實現，Standalone模式下具體的實現是TaskSchedulerImpl。SchedulerBackend是一個介面，根據具體的ClusterManager的不同會有不同的實現。Standalone模式下具體的實現是StandaloneSchedulerBackend。下圖為SparkContext整體執行圖
從整個程式執行的角度講，SparkContext包含四大核心物件：DAGScheduler、TaskScheduler、SchedulerBackend、MapOutputTrackerMaster。StandaloneSchedulerBackend有三大核心功能：負責與Master連線，註冊當前程式RegisterWithMaster；接收叢集中為當前應用程式分配的計算資源Executor的註冊並管理Executors；負責傳送Task到具體的Executor執行。
第一步：程式一開始執行時會例項化SparkContext裡的物件，所有不在方法裡的成員都會被例項化！一開始例項化時第一個關鍵的程式碼是createTaskScheduler，它位於SparkContext的PrimaryConstructor中，當它例項化時會直接被呼叫，這個方法返回的是taskScheduler和dagScheduler的例項，然後基於這個內容又構建了DAGScheduler，最後呼叫taskScheduler的start()方法。要先建立taskScheduler，然後再建立dagScheduler，因為taskScheduler是受dagScheduler管理的。
SparkContext.scala的原始碼如下。
// Create and start the scheduler val (sched, ts) = SparkContext.createTaskScheduler(this, master, deployMode) _schedulerBackend = sched _taskScheduler = ts _dagScheduler = new DAGScheduler(this) _heartbeatReceiver.ask[Boolean](TaskSchedulerIsSet) // start TaskScheduler after taskScheduler sets DAGScheduler reference in DAGScheduler's // constructor _taskScheduler.start()
第二步：呼叫createTaskScheduler，這個方法建立了TaskSchedulerImpl和StandaloneSchedulerBackend，createTaskScheduler方法的第一個入參是SparkContext，傳入的this物件是在應用程式中建立的sc，第二個入參是master的地址。
以下是wordcount.scala建立SparkConf和SparkContext的上下文資訊
// 第1步：建立Spark的配置物件SparkConf，設定Spark程式執行時的配置資訊， val conf = new SparkConf().setAppName("My First Spark APP").setMaster("local") // 第2步：建立SparkContext物件 val sc = new SparkContext(conf)
當SparkContext呼叫createTaskScheduler方法時，根據叢集的條件建立不同的排程器，例如，createTaskScheduler第二個入參master如傳入local引數，SparkContext將建立TaskSchedulerImpl例項及LocalSchedulerBackend例項，在測試程式碼的時候，可以嘗試傳入local[*]或者是local[2]的引數，然後跟蹤程式碼，看看建立了什麼樣的例項物件。
SparkContext中的SparkMasterRegex物件定義不同的正規表示式，從master字串中根據正規表示式適配master資訊。
SparkContext.scala的原始碼如下。
/** * A collection of regexes for extracting information from the master string. */ private object SparkMasterRegex { // Regular expression used for local[N] and local[*] master formats val LOCAL_N_REGEX = """local\[([0-9]+|\*)\]""".r // Regular expression for local[N, maxRetries], used in tests with failing tasks val LOCAL_N_FAILURES_REGEX = """local\[([0-9]+|\*)\s*,\s*([0-9]+)\]""".r // Regular expression for simulating a Spark cluster of [N, cores, memory] locally val LOCAL_CLUSTER_REGEX = """local-cluster\[\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*]""".r // Regular expression for connecting to Spark deploy clusters val SPARK_REGEX = """spark://(.*)""".r // Regular expression for connection to Mesos cluster by mesos:// or mesos://zk:// url val MESOS_REGEX = """mesos://(.*)""".r }
這是設計模式中的策略模式，它會根據實際需要建立出不同的SchedulerBackend的子類。
SparkContext.scala的createTaskScheduler方法的原始碼如下。
/** * Create a task scheduler based on a given master URL. * Return a 2-tuple of the scheduler backend and the task scheduler. */ private def createTaskScheduler( sc: SparkContext, master: String, deployMode: String): (SchedulerBackend, TaskScheduler) = { import SparkMasterRegex._ // When running locally, don't try to re-execute tasks on failure. val MAX_LOCAL_TASK_FAILURES = 1 master match { case "local" => val scheduler = new TaskSchedulerImpl(sc, MAX_LOCAL_TASK_FAILURES, isLocal = true) val backend = new LocalSchedulerBackend(sc.getConf, scheduler, 1) scheduler.initialize(backend) (backend, scheduler)
在實際生產環境下，我們都是用叢集模式，即以spark://開頭，此時在程式執行時，框架會建立一個TaskSchedulerImpl和StandaloneSchedulerBackend的例項，在這個過程中也會初始化taskscheduler，把StandaloneSchedulerBackend的例項物件作為引數傳入。StandaloneSchedulerBackend被TaskSchedulerImpl管理，最後返回TaskScheduler和StandaloneSchdeulerBackend。
SparkContext.scala的原始碼如下。
case SPARK_REGEX(sparkUrl) => val scheduler = new TaskSchedulerImpl(sc) val masterUrls = sparkUrl.split(",").map("spark://" + _) val backend = new StandaloneSchedulerBackend(scheduler, sc, masterUrls) scheduler.initialize(backend) (backend, scheduler)
createTaskScheduler方法執行完畢後，呼叫了taskscheduler.start()方法來正式啟動taskscheduler，這裡雖然呼叫了taskscheduler.start方法，但實際上是呼叫了taskSchedulerImpl的start方法，因為taskSchedulerImpl是taskScheduler的子類。
Task預設失敗重試次數是4次，如果任務不容許失敗，就可以調大這個引數。調大spark.task.maxFailures引數有助於確保重要的任務失敗後可以重試多次。
初始化TaskSchedulerImpl：呼叫createTaskScheduler方法時會初始化TaskSchedulerImpl，然後把StandaloneSchedulerBackend當作引數傳進去，初始化TaskSchedulerImpl時首先是建立一個Pool來初定義資源分佈的模式Scheduling Mode，預設是先進先出（FIFO）的模式。
回到taskScheduler start方法，taskScheduler.start方法呼叫時會再呼叫schedulerbackend的start方法。
SchedulerBackend包含多個子類，分別是LocalSchedulerBackend、CoarseGrainedScheduler-Backend和StandaloneSchedulerBackend、MesosCoarseGrainedSchedulerBackend、YarnScheduler-Backend。
StandaloneSchedulerBackend的start方法呼叫了CoarseGraninedSchedulerBackend的start方法，通過StandaloneSchedulerBackend註冊程式把command提交給Master：Command ("org.apache.spark.executor.CoarseGrainedExecutorBackend", args, sc.executorEnvs, classPathEntries ++ testingClassPath, libraryPathEntries, javaOpts)來建立一個StandaloneAppClient的例項。
Master發指令給Worker去啟動Executor所有的程式時載入的Main方法所在的入口類就是command中的CoarseGrainedExecutorBackend，在CoarseGrainedExecutorBackend中啟動Executor（Executor是先註冊，再例項化），Executor通過執行緒池併發執行Task，然後再呼叫它的run方法。
回到StandaloneSchedulerBackend.scala的start方法：其中建立了一個很重要的物件，即StandaloneAppClient物件，然後呼叫它的client.start()方法。
在start方法中建立一個ClientEndpoint物件。
StandaloneAppClient.scala的star方法的原始碼如下。
def start() { // Just launch an rpcEndpoint; it will call back into the listener. endpoint.set(rpcEnv.setupEndpoint("AppClient", new ClientEndpoint(rpcEnv))) }
ClientEndpoint是一個RpcEndPoint，首先呼叫自己的onStart方法，接下來向Master註冊。
呼叫registerWithMaster方法，從registerWithMaster呼叫tryRegisterAllMasters，開一條新的執行緒來註冊，然後傳送一條資訊（RegisterApplication的case class）給Master。
Master收到RegisterApplication資訊後便開始註冊，註冊後再次呼叫schedule()方法。
四、總結
從SparkContext建立taskSchedulerImpl初始化不同的例項物件來完成最終向Master註冊的任務，中間包括呼叫scheduler的start方法和建立StandaloneAppClient來間接建立ClientEndPoint完成註冊工作。
我們把SparkContext稱為天堂之門，SparkContext開啟天堂之門：Spark程式是通過SparkContext釋出到Spark叢集的；SparkContext導演天堂世界：Spark程式的執行都是在SparkContext為核心的排程器的指揮下進行的；SparkContext關閉天堂之門：SparkContext崩潰或者結束的時候整個Spark程式也結束。