【极速学习spark源码】spark-submit 背后到底发生了什么

基于 Spark 4.2，分支 branch-4.2

阅读时长约 6 分钟 · 入门到中级

背景

我们每天都会敲：

bin/spark-submit \  --verbose \  --class org.apache.spark.examples.SparkPi \  --master local[2] \  examples/jars/spark-examples_2.13-4.2.0.jar \  10

但这条命令背后发生了什么？

它是直接启动你的 main 方法吗？它什么时候决定是 client mode 还是 cluster mode？它为什么同一套命令能跑 local、Standalone、YARN、Kubernetes？

改文章走一遍 spark-submit 的源码路径。

一、流程图：从 shell 到用户 main

下面是简化后的主路径。严格来说，spark-submit 会先进入 spark-class，再由 launcher 生成最终 JVM 命令，最后才进入 SparkSubmit.main。

bin/spark-submit    ↓bin/spark-class org.apache.spark.deploy.SparkSubmit    ↓SparkSubmit.main    ↓new SparkSubmit().doSubmit(args)    ↓SparkSubmitArguments 解析参数    ↓prepareSubmitEnvironment    ├─ 判断 cluster manager: local / standalone / yarn / k8s    ├─ 判断 deploy mode: client / cluster    ├─ 组装 childClasspath    ├─ 组装 childArgs    └─ 选择 childMainClass    ↓runMain    ↓加载 childMainClass    ↓SparkApplication.start    ↓JavaMainApplication.start    ↓用户 main(args)

一句话：

spark-submit 自己不是你的应用。它是一个“启动器”，负责把参数翻译成一个真正要运行的 main class。

二、shell 层：spark-submit 只是一层包装

打开 bin/spark-submit:27：

exec "${SPARK_HOME}"/bin/spark-class org.apache.spark.deploy.SparkSubmit "$@"

spark-submit 本身很薄。它只做了两件事：

找到 SPARK_HOME
调用 spark-class 启动 org.apache.spark.deploy.SparkSubmit

真正复杂的逻辑在 Scala 代码里。

三、入口：SparkSubmit.main

SparkSubmit.scala:1103 是 companion object：

object SparkSubmit extends CommandLineUtils with Logging

真正入口在 SparkSubmit.scala:1133：

override def main(args: Array[String]): Unit = {  Option(System.getenv("SPARK_PREFER_IPV6"))    .foreach(System.setProperty("java.net.preferIPv6Addresses", _))  val submit = new SparkSubmit() {    self =>    overrideprotected def parseArguments(args: Array[String]): SparkSubmitArguments = {      new SparkSubmitArguments(args) { ... }    }  }  submit.doSubmit(args)}

注意这里不是直接运行用户程序，而是：

创建 SparkSubmit
解析命令行参数
进入 doSubmit

四、doSubmit：决定“提交动作”

SparkSubmit.scala:70。下面是简化后的代码：、

def doSubmit(args: Array[String]): Unit = {  val appArgs = parseArguments(args)  appArgs.action match {    case SparkSubmitAction.SUBMIT => submit(appArgs, true, appArgs.toSparkConf())    case SparkSubmitAction.KILL => kill(appArgs)    case SparkSubmitAction.REQUEST_STATUS => requestStatus(appArgs)    case SparkSubmitAction.PRINT_VERSION => printVersion()  }}

spark-submit 其实不只会提交任务，还能：

--kill 杀掉应用
--status 查询状态
--version 打印版本

日常最常见的是 SUBMIT，也就是进入 submit(...)。

五、submit：处理 proxy user 和 Standalone REST fallback

SparkSubmit.scala:166。下面是简化后的代码：

private def submit(args: SparkSubmitArguments, uninitLog: Boolean, sparkConf: SparkConf): Unit = {  def doRunMain(): Unit = {    if (args.proxyUser != null) {      // 用 Hadoop UGI 代理用户运行      proxyUser.doAs(new PrivilegedExceptionAction[Unit]() {        override def run(): Unit = {          runMain(args, uninitLog)        }      })    } else {      runMain(args, uninitLog)    }  }  if (args.isStandaloneCluster && args.useRest) {    try {      doRunMain()    } catch {      case e: SubmitRestConnectionException =>        args.useRest = false        submit(args, false, sparkConf)    }  } else {    doRunMain()  }}

这一步的重点不是启动用户程序，而是做两类“提交前保护”：

如果指定了 --proxy-user，用对应用户身份执行
Standalone cluster 模式下优先用 REST 提交，失败后 fallback 到老的 RPC 提交

真正准备环境在下一步。

六、prepareSubmitEnvironment：spark-submit 的核心

SparkSubmit.scala:243 是最重要的入口。下面是简化后的代码：

private[deploy] def prepareSubmitEnvironment(    args: SparkSubmitArguments,    conf: Option[HadoopConfiguration] = None)    : (Seq[String], Seq[String], SparkConf, String) = {  val childArgs = new ArrayBuffer[String]()  val childClasspath = new ArrayBuffer[String]()  val sparkConf = args.toSparkConf()  var childMainClass = ""  val clusterManager: Int = args.maybeMaster match {    caseSome("yarn") => YARN    case Some(m) if m.startsWith("spark") => STANDALONE    case Some(m) if SparkMasterRegex.isK8s(m) => KUBERNETES    case Some(m) if m.startsWith("local") => LOCAL    case None => LOCAL  }  val deployMode: Int = args.deployMode match {    case "client" | null => CLIENT    case "cluster" => CLUSTER  }  // 后面根据 clusterManager + deployMode 选择 childMainClass / childArgs / classpath}

它返回四个东西：

返回值	含义
`childArgs`	真正传给 child main class 的参数
`childClasspath`	需要额外加入 classloader 的 jar / path
`sparkConf`	最终合并后的 SparkConf
`childMainClass`	真正要启动的 main class

这就是 spark-submit 的核心：把用户命令翻译成 childMainClass + childArgs + childClasspath + SparkConf。

七、client mode vs cluster mode，到底差在哪

很多人以为 deploy mode 是“调度器不同”。不是。

deploy mode 只回答一个问题：

Driver 运行在哪里？

deploy mode	Driver 位置	spark-submit 进程做什么
client	就在提交机器上	直接启动用户 main
cluster	在集群里, 随机一个机器启动driver	启动一个集群客户端，把 Driver 交给集群管理器

所以在 client mode 下, 你可以使用`jps`查看到SparkSubmit进程的存在：

spark-submit JVM  → SparkSubmit    → 用户 main      → new SparkContext        → 连接集群

在 cluster mode 下：

spark-submit JVM  → SparkSubmit    → 集群提交客户端 main      → 向 YARN/K8s/Standalone 提交 Driver集群中的 Driver JVM  → 用户 main    → new SparkContext

prepareSubmitEnvironment 根据 clusterManager + deployMode 选择不同 childMainClass。例如 SparkSubmit.scala:1126-1131 定义了几类 cluster 提交入：

private[deploy] val YARN_CLUSTER_SUBMIT_CLASS =  "org.apache.spark.deploy.yarn.YarnClusterApplication"private[deploy] val STANDALONE_CLUSTER_SUBMIT_CLASS = classOf[ClientApp].getName()private[deploy] val KUBERNETES_CLUSTER_SUBMIT_CLASS =  "org.apache.spark.deploy.k8s.submit.KubernetesClientApplication"

也就是说：

YARN cluster：先跑 YarnClusterApplication
Standalone cluster：先跑 ClientApp
Kubernetes cluster：先跑 KubernetesClientApplication

它们负责把真正的 Driver 交给对应的集群管理器。

八、runMain：加载 childMainClass

SparkSubmit.scala:964。下面是简化后的代码：

private def runMain(args: SparkSubmitArguments, uninitLog: Boolean): Unit = {  val (childArgs, childClasspath, sparkConf, childMainClass) = prepareSubmitEnvironment(args)  val loader = getSubmitClassLoader(sparkConf)  for (jar <- childClasspath) {    addJarToClasspath(jar, loader)  }  var mainClass: Class[_] = null  mainClass = Utils.classForName(childMainClass)  val app: SparkApplication = if (classOf[SparkApplication].isAssignableFrom(mainClass)) {    mainClass.getConstructor().newInstance().asInstanceOf[SparkApplication]  } else {    new JavaMainApplication(mainClass)  }  app.start(childArgs.toArray, sparkConf)}

这里有两个关键点。

第一，Spark 不是直接反射调用用户 main，而是先包装成 SparkApplication。

第二，如果 childMainClass 本身实现了 SparkApplication，直接用它；否则用 JavaMainApplication 包一层。

九、SparkApplication：统一入口协议

SparkApplication.scala:27：

private[spark] traitSparkApplication{  def start(args: Array[String], conf: SparkConf): Unit}

标准 Java/Scala 应用会被包装成 JavaMainApplication。看 SparkApplication.scala:39：

private[deploy] class JavaMainApplication(klass: Class[_]) extends SparkApplication {  override def start(args: Array[String], conf: SparkConf): Unit = {    val mainMethod = klass.getMethod("main", new Array[String](0).getClass)    val sysProps = conf.getAll.toMap    sysProps.foreach { case (k, v) =>      sys.props(k) = v    }    mainMethod.invoke(null, args)  }}

也就是：

找到用户类的 main(Array[String])
把 SparkConf 写入 JVM system properties
反射调用用户 main

这时，你的代码终于开始执行。

十、用户 main 之后：SparkContext 才真正创建

spark-submit 本身不会创建 SparkContext。

真正创建 SparkContext 的通常是你的应用代码：

val spark = SparkSession.builder().getOrCreate()

或者：

val sc = new SparkContext(conf)

这件事发生在你的 main 方法内部。

这也是很多初学者混淆的一点：

spark-submit 负责启动 Driver
Driver 里面的用户代码负责创建 SparkContext
SparkContext 再创建 DAGScheduler / TaskScheduler / SparkEnv

换句话说：spark-submit 不等于 SparkContext。spark-submit 只是把你的程序跑起来。

十一、样例测试：看 verbose 输出

最简单的观察方式是加 --verbose：

bin/spark-submit \--verbose \--class org.apache.spark.examples.SparkPi \--master local[2] \  examples/jars/spark-examples_2.13-4.2.0.jar \10

看到相关得信息：

Main class:org.apache.spark.examples.SparkPiArguments:10Spark config:...Classpath elements:...

这些信息正是 runMain 中 args.verbose 分支打印的，源码在 SparkSubmit.scala:971-979。

十二、总结

完整路径回顾：

bin/spark-submit:27  → bin/spark-class org.apache.spark.deploy.SparkSubmit    → SparkSubmit.main:1133      → new SparkSubmit().doSubmit        → SparkSubmit.doSubmit:70          → SparkSubmit.submit:166            → SparkSubmit.runMain:964              → prepareSubmitEnvironment:243                → 解析 master / deploy-mode / classpath / child main              → Utils.classForName(childMainClass)              → SparkApplication.start                → JavaMainApplication.start:41                  → 用户 main(args)                    → SparkSession.builder.getOrCreate / new SparkContext

最值得关注的三个经验：

spark-submit 是启动器，不是应用本身。 它负责解析参数、拼 classpath、决定 child main class，然后把控制权交出去。
client / cluster mode 的本质差异是 Driver 位置。 client mode 下 Driver 就在 spark-submit 进程里；cluster mode 下 spark-submit 先启动一个提交客户端，由集群管理器再拉起 Driver。
SparkContext 通常不是 spark-submit 创建的，而是用户 main 创建的。spark-submit 到 SparkContext 中间隔着 JavaMainApplication.start → 用户 main。

每天花费10分钟学习spark，让你技术之路走得更稳、更快。
喜欢的点个关注。