##SparkContext启动过程
基于spark 2.1.0 scala 2.11.8
spark源码的体系结构实在是很庞大，从使用spark-submit脚本提交任务，到向yarn申请容器，启动driver进程，启动executor进程，到任务调度，shuffle过程等等，模块众多，而且每个模块都很大，所以要全部看完啃透几乎不可能，一是经历不允许，而是有些边缘性的模块主要起到辅助的功能，没有什么高深的技术含量，花时间性价比不高。因此我决定略去前面提交任务，向yarn提交任务，申请资源，启动容器的部分，以用户代码的运行为切入点，从SparkContext开始看起，当然spark从1.6之后一直以SparkSession作为用户编程的主要api，但是SparkSession实际仅仅是对SparkContext，SQLContext等入口对象的进一步分装，而涉及到spark核心模块的还是SparkContext。
###SparkContext启动流程
启动流程在SparkContext的初始化块中，在scala类中，可以直接在类作用域内执行一些代码块，这些代码块的作用就相当于java中类的实例初始化块，在实例初始化时被调用，因此一般会有一些初始化的逻辑在这里。我们看一下SparkContext类，除了前面几个内部常量成员的初始化，之后就是这段try块的执行了。感觉这点也是scala语法的一个缺点，java中借助IDE可以很快找到类的初始化代码，而iDEA对scala类的这种代码块并没有特别的突出，因此需要看代码的时候很仔细，否则很有可能就遗漏了一些重要的代码。
try {
// 引用克隆，与外部传进来的conf隔离
_conf = config.clone()
_conf.validateSettings()
if (!_conf.contains("spark.master")) {
throw new SparkException("A master URL must be set in your configuration")
}
if (!_conf.contains("spark.app.name")) {
throw new SparkException("An application name must be set in your configuration")
}
// log out spark.app.name in the Spark driver logs
logInfo(s"Submitted application: $appName")
// System property spark.yarn.app.id must be set if user code ran by AM on a YARN cluster
if (master == "yarn" && deployMode == "cluster" && !_conf.contains("spark.yarn.app.id")) {
throw new SparkException("Detected yarn cluster mode, but isn't running on a cluster. " +
"Deployment to YARN is not supported directly by SparkContext. Please use spark-submit.")
}
if (_conf.getBoolean("spark.logConf", false)) {
logInfo("Spark configuration:\n" + _conf.toDebugString)
}
// Set Spark driver host and port system properties. This explicitly sets the configuration
// instead of relying on the default value of the config constant.
_conf.set(DRIVER_HOST_ADDRESS, _conf.get(DRIVER_HOST_ADDRESS))
_conf.setIfMissing("spark.driver.port", "0")
_conf.set("spark.executor.id", SparkContext.DRIVER_IDENTIFIER)
_jars = Utils.getUserJars(_conf)
_files = _conf.getOption("spark.files").map(_.split(",")).map(_.filter(_.nonEmpty))
.toSeq.flatten
_eventLogDir =
if (isEventLogEnabled) {
val unresolvedDir = conf.get("spark.eventLog.dir", EventLoggingListener.DEFAULT_LOG_DIR)
.stripSuffix("/")
Some(Utils.resolveURI(unresolvedDir))
} else {
None
}
_eventLogCodec = {
val compress = _conf.getBoolean("spark.eventLog.compress", false)
if (compress && isEventLogEnabled) {
Some(CompressionCodec.getCodecName(_conf)).map(CompressionCodec.getShortName)
} else {
None
}
}
// 事件总线
_listenerBus = new LiveListenerBus(_conf)
// Initialize the app status store and listener before SparkEnv is created so that it gets
// all events.
// 应用状态存储, 在SparkEnv创建之前将监听器加到事件注册到事件总线中，以能够监听到SparkEnv的事件
_statusStore = AppStatusStore.createLiveStore(conf)
listenerBus.addToStatusQueue(_statusStore.listener.get)
// Create the Spark execution environment (cache, map output tracker, etc)
// 创建SparkEnv，是spark的重要的基础设施
_env = createSparkEnv(_conf, isLocal, listenerBus)
SparkEnv.set(_env)
// If running the REPL, register the repl's output dir with the file server.
_conf.getOption("spark.repl.class.outputDir").foreach { path =>
val replUri = _env.rpcEnv.fileServer.addDirectory("/classes", new File(path))
_conf.set("spark.repl.class.uri", replUri)
}
_statusTracker = new SparkStatusTracker(this, _statusStore)
_progressBar =
if (_conf.get(UI_SHOW_CONSOLE_PROGRESS) && !log.isInfoEnabled) {
Some(new ConsoleProgressBar(this))
} else {
None
}
_ui =
if (conf.getBoolean("spark.ui.enabled", true)) {
Some(SparkUI.create(Some(this), _statusStore, _conf, _env.securityManager, appName, "",
startTime))
} else {
// For tests, do not enable the UI
None
}
// Bind the UI before starting the task scheduler to communicate
// the bound port to the cluster manager properly
// 启动spark ui
_ui.foreach(_.bind())
// 创建hadoop config配置，以spark.hadoop开头的配置
_hadoopConfiguration = SparkHadoopUtil.get.newConfiguration(_conf)
// Add each JAR given through the constructor
// 添加spark.jars参数指定的文件
if (jars != null) {
jars.foreach(addJar)
}
// 添加spark.files参数指定的文件
if (files != null) {
files.foreach(addFile)
}
// 可以看出参数的取值顺序
_executorMemory = _conf.getOption("spark.executor.memory")
.orElse(Option(System.getenv("SPARK_EXECUTOR_MEMORY")))
.orElse(Option(System.getenv("SPARK_MEM"))
.map(warnSparkMem))
.map(Utils.memoryStringToMb)
.getOrElse(1024)
// Convert java options to env vars as a work around
// since we can't set env vars directly in sbt.
for {(envKey, propKey) <- Seq(("SPARK_TESTING", "spark.testing"))
value <- Option(System.getenv(envKey)).orElse(Option(System.getProperty(propKey)))} {
executorEnvs(envKey) = value
}
Option(System.getenv("SPARK_PREPEND_CLASSES")).foreach { v =>
executorEnvs("SPARK_PREPEND_CLASSES") = v
}
// The Mesos scheduler backend relies on this environment variable to set executor memory.
// TODO: Set this only in the Mesos scheduler.
executorEnvs("SPARK_EXECUTOR_MEMORY") = executorMemory + "m"
executorEnvs ++= _conf.getExecutorEnv
executorEnvs("SPARK_USER") = sparkUser
// We need to register "HeartbeatReceiver" before "createTaskScheduler" because Executor will
// retrieve "HeartbeatReceiver" in the constructor. (SPARK-6640)
// 必须要在创建TaskScheduler之前先注册HeartbeatReceiver，
// 因为Executor的构造方法参数中需要HeartbeatReceiver
_heartbeatReceiver = env.rpcEnv.setupEndpoint(
HeartbeatReceiver.ENDPOINT_NAME, new HeartbeatReceiver(this))
// Create and start the scheduler
// 创建并启动调度器，包括调度后端，任务调度器
val (sched, ts) = SparkContext.createTaskScheduler(this, master, deployMode)
_schedulerBackend = sched
_taskScheduler = ts
// 创建DAG调度器
_dagScheduler = new DAGScheduler(this)
// 端点引用，类似于RPC中的stup，调用端
// 发送一个
_heartbeatReceiver.ask[Boolean](TaskSchedulerIsSet)
// start TaskScheduler after taskScheduler sets DAGScheduler reference in DAGScheduler's
// constructor
_taskScheduler.start()
_applicationId = _taskScheduler.applicationId()
_applicationAttemptId = taskScheduler.applicationAttemptId()
_conf.set("spark.app.id", _applicationId)
if (_conf.getBoolean("spark.ui.reverseProxy", false)) {
System.setProperty("spark.ui.proxyBase", "/proxy/" + _applicationId)
}
_ui.foreach(_.setAppId(_applicationId))
_env.blockManager.initialize(_applicationId)
// The metrics system for Driver need to be set spark.app.id to app ID.
// So it should start after we get app ID from the task scheduler and set spark.app.id.
_env.metricsSystem.start()
// Attach the driver metrics servlet handler to the web ui after the metrics system is started.
_env.metricsSystem.getServletHandlers.foreach(handler => ui.foreach(_.attachHandler(handler)))
// 事件记录器，监听事件总线上的事件，将事件记录到日志中
_eventLogger =
if (isEventLogEnabled) {
val logger =
new EventLoggingListener(_applicationId, _applicationAttemptId, _eventLogDir.get,
_conf, _hadoopConfiguration)
logger.start()
listenerBus.addToEventLogQueue(logger)
Some(logger)
} else {
None
}
// Optionally scale number of executors dynamically based on workload. Exposed for testing.
// 动态申请executor
val dynamicAllocationEnabled = Utils.isDynamicAllocationEnabled(_conf)
_executorAllocationManager =
if (dynamicAllocationEnabled) {
schedulerBackend match {
case b: ExecutorAllocationClient =>
Some(new ExecutorAllocationManager(
schedulerBackend.asInstanceOf[ExecutorAllocationClient], listenerBus, _conf))
case _ =>
None
}
} else {
None
}
_executorAllocationManager.foreach(_.start())
// 清理器，用于清理RDD,shuffle，广播变量等的状态
_cleaner =
if (_conf.getBoolean("spark.cleaner.referenceTracking", true)) {
Some(new ContextCleaner(this))
} else {
None
}
_cleaner.foreach(_.start())
// 添加通过spark.extraListeners参数设置的监听器，然后启动事件总线
setupAndStartListenerBus()
// 投递一个环境更新的事件到事件总线中
postEnvironmentUpdate()
// 投递一个应用启动的事件到事件总线中
postApplicationStart()
// Post init
// 调用任务调度器的前置方法
_taskScheduler.postStartHook()
// 添加对DAG调度器的度量源，主要用于获取任务数，运行的任务数，成功，失败，运行的stage数目
_env.metricsSystem.registerSource(_dagScheduler.metricsSource)
// 添加对块管理器的度量源，主要用于统计内存使用量
_env.metricsSystem.registerSource(new BlockManagerSource(_env.blockManager))
// 添加对executor申请管理器的度量源，主要用于统计申请的executor的统计信息
_executorAllocationManager.foreach { e =>
_env.metricsSystem.registerSource(e.executorAllocationManagerSource)
}
// Make sure the context is stopped if the user forgets about it. This avoids leaving
// unfinished event logs around after the JVM exits cleanly. It doesn't help if the JVM
// is killed, though.
logDebug("Adding shutdown hook") // force eager creation of logger
// 添加关闭SparkContext的钩子
_shutdownHookRef = ShutdownHookManager.addShutdownHook(
ShutdownHookManager.SPARK_CONTEXT_SHUTDOWN_PRIORITY) { () =>
logInfo("Invoking stop() from shutdown hook")
stop()
}
} catch {
case NonFatal(e) =>
logError("Error initializing SparkContext.", e)
try {
stop()
} catch {
case NonFatal(inner) =>
logError("Error stopping SparkContext after init error.", inner)
} finally {
throw e
}
}
总结一下这段代码的主要逻辑：
* 处理配置参数
* ***创建事件总线LiveListenerBus，用于发布事件，监听事件***
* 创建程序状态存储器AppStatusStore，是一个KV存储的包装类。并且将与此存储器关联的监听器添加到事件总线的appStatus队列中，监听appStatus类型的事件
* ***创建SparkEnv对象，这个对象是spark的执行环境，是spark中最重要的类之一，内部分装了块管理器，shuffle管理器，map输出跟踪器，广播管理器，内存管理器等重要的基础设施，是spark运行的基石。***
* 创建状态跟踪器，用于跟踪job和stage的执行情况，
* 创建控制台进度条，用于往控制台打印stage运行进度信息
* 创建ui对象，用于提供web页面访问服务
* 将spark.jars和spark.files添加到NettyStreamManager中以提供文件下载服务，executor会通过rpc下载这些文件
* 设置executor的一些环境变量，
* 创建心跳接收器，并创建一个端点引用
* ***创建调度后端和任务调度器，以常用的yarn cluster模式为例，创建的是YarnClusterScheduler和YarnClusterSchedulerBackend***
* ***创建DAG调度器，dag调度器运行任务是通过向任务调度器提交任务实现的***
* 启动任务调度器，内部启动了调度后端
* 初始化块管理器，启动度量系统，
* 创建动态申请资源的管理器，如果没有启用动态资源，那么这一项为空
* 创建清理器，用于清理RDD,shuffle，广播变量等的状态
* 向度量系统注册三个度量源，分别是DAG调度器度量源，块管理器度量源，动态资源申请管理器度量源
* 最后添加一个程序退出的钩子函数，用于在程序退出时关闭SparkContext
其中斜体加粗的几个模块是重点模块。后面会从一次RDD行动算子运行为切入点，分析在一次完整的spark任务运行过程中涉及到那些模块，以及各个模块之间是如何协同配合，在这个过程中逐步弄清楚每个模块的作用以及内部运行机制，任重而道远啊！！