1.3 Driver-Executor 架构与作业生命周期
1.2 讲完了「一张血缘图」,这一节讲这张图在集群里怎么变成真正跑起来的任务。Spark 的角色分工可以浓缩成一句话:Driver 动脑,Executor 动手,Cluster Manager 提供人手。理解三个角色的职责边界与失败语义,是后面讲 DAG 调度、Shuffle、容错的基础。
三个角色
| 角色 | 位置 | 职责 | 生命周期 |
|---|---|---|---|
| Driver | 提交作业的进程 | 解析代码、构建血缘、划分 Stage、调度任务、收集结果 | 与作业同生共死 |
| Executor | 集群工作节点 | 执行 Task、缓存 RDD 分区、提供 shuffle 数据 | 可被动态增删 |
| Cluster Manager | 集群层 | 分配与回收资源(YARN / K8s / Standalone) | 常驻 |
Driver 是唯一的规划者:它不看数据内容,只看血缘图与分区元数据,决定「先跑哪个 Stage、每个 Stage 发多少任务、任务优先发到哪台机器」。Executor 是纯粹的执行者:它不参与规划,收到 Task 就执行,执行完汇报状态与结果。
这种「中心规划 + 边缘执行」的分工,与卷一 YARN 的架构同构:YARN 的 ResourceManager 管资源、ApplicationMaster 管单个应用的调度、NodeManager 管节点。Spark 的 Driver 同时扮演了后两者的角色(应用级调度 + 任务级调度),Executor 则对应容器里的执行进程。
作业生命周期:从一行代码到一批任务
一次行动触发的完整链路:
1. 用户调用 action(如 count())
2. Driver 沿血缘图回溯,构建 Job
3. 按宽依赖切分 Stage(第 3 章)
4. 每个 Stage 生成 TaskSet(任务数 = 分区数)
5. TaskScheduler 把 Task 分给 Executor(考虑本地性)
6. Executor 执行 Task,读输入、算、写输出
7. 每个 Task 完成后向 Driver 汇报
8. 全部完成 → Job 完成,Result 返回用户
对比卷一 MapReduce 的作业流程:MR 的 Job 一次性提交给 MRAppMaster,由它分配 map/reduce 任务;Spark 的 Job 由 Driver 在进程内规划,Driver 直接持有调度逻辑。MR 的调度是「提交出去」,Spark 的调度是「自己算」——前者把调度器放在集群里,后者放在客户端/驱动进程里。
Driver 里到底有什么
Driver 不是一个「转发器」,它的内存里装着作业的全部元数据:
| 组件 | 作用 |
|---|---|
| SparkContext | 作业入口,持有配置与集群连接 |
| DAGScheduler | 把 RDD 图划成 Stage,按依赖提交 |
| TaskScheduler | 把 TaskSet 分给 Executor,处理本地性 |
| SchedulerBackend | 与 Cluster Manager / Executor 通信 |
| 结果收集器 | 收回 action 的结果(collect 等) |
前两个是「规划层」,后三个是「执行层」。这也解释了为什么 Driver 内存要足够:血缘图、Stage 元数据、任务状态都在它这里。作业规模很大时,Driver 可能成为瓶颈——这不是设计缺陷,而是「中心规划」的固有代价。
Executor 里有什么
Executor 是一个长期驻留的进程,里面并行跑多个 Task:
| 组件 | 作用 |
|---|---|
| Task 执行线程池 | 并发执行任务,线程数 = 核数 |
| BlockManager | 管理缓存分区与 shuffle 数据 |
| Shuffle 服务 | 提供其他 Executor 拉取的 shuffle 文件 |
| 内存池 | 执行内存 + 存储内存(第 5 章) |
注意「线程数 = 核数」这一点:Spark 的任务是线程级并行,不是进程级。一个 Executor 有 4 核就同时跑 4 个 Task,共享同一份堆内存。这个设计让任务启动开销远小于 MR(MR 每个任务一个 JVM),但也让 Executor 内的任务互相影响——一个任务 OOM 可能拖垮整个 Executor 上的其他任务。
作业、阶段、任务的三层结构
Spark 的调度单位是三层嵌套:
| 层级 | 定义 | 数量由什么决定 |
|---|---|---|
| Job | 一次 action 触发的完整计算 | 行动次数 |
| Stage | 按宽依赖切分的一段流水线 | 依赖图中的唯一 shuffle 与结果阶段 |
| Task | Stage 内一个分区的计算 | 该 Stage 的分区数 |
一个 Job 有多个 Stage,一个 Stage 有多个 Task。Stage 是「可以流水线执行的一段」,Task 是「一个分区的一份工作」。这三层的数量关系,就是第 3 章 DAG 调度器的输入。
lab 的 DagPlanner.countStages 验证:3 个窄依赖 + 1 个宽依赖 → 2 个 Stage(用例 1);RddCore.tasks(partitions, slots) 验证任务并发受槽位限制(用例 12)。Stage 数看宽依赖,Task 数看分区,并发数看槽位——三个数字各管一层。
失败语义:Driver 单点,Executor 可替换
两个角色的失败后果完全不同:
| 失败对象 | 后果 | 恢复方式 |
|---|---|---|
| Executor 挂掉 | 它上面的 Task 与缓存丢失 | 任务重新调度、缓存按血缘重算 |
| Driver 挂掉 | 整个作业失败(作业元数据丢失) | 作业重跑(或靠外部编排重提交) |
这是「中心规划」的直接代价:Driver 是作业的单点。Spark 后来的 Standalone 高可用、YARN/K8s 上的自动重启,都是在缓解这一点,但本质没有变——Driver 内存里的血缘与 Stage 状态,没有持久化到可靠存储。
对比卷一 HDFS 的 NameNode 高可用(5.2):NameNode 用共享编辑日志与主备切换解决单点;Spark 的 Driver 没有等价的机制,因为它假设「作业失败可以整体重跑」——批处理作业的时长通常在分钟到小时级,整体重跑是可接受的。这是批处理与存储系统对可用性要求不同的直接体现。
一次作业的时序
把生命周期摊开成时序,能看清每一步谁在等谁:
用户线程 Driver(DAGScheduler/TaskScheduler) Executor
| action() |
|------------------->| 构建 Job
| | 沿血缘切 Stage
| | Stage0 的 TaskSet 就绪
| |---- 分配 Task ---> [Task 1..N]
| | 执行、汇报
| |<--- 状态更新 -------|
| | Stage0 完成,提交 Stage1
| |---- 分配 Task ---> [Task 1..M]
| |<--- 状态更新 -------|
|<-- 结果返回 --------|
关键在「Stage 之间必须等」:Stage1 的输入是 Stage0 的输出(shuffle 数据),所以 Stage0 的全部任务完成后,Stage1 才能开始。Stage 内部的任务则可以并行、可以流水线,不必互相等待。
为什么任务用线程而不是进程
MR 的每个任务是一个独立 JVM 进程,Spark 的每个任务是一个线程。这个差异带来三个直接后果:
| 维度 | MR 进程级 | Spark 线程级 |
|---|---|---|
| 启动开销 | 每任务一次 JVM 启动 | 线程池复用,几乎为零 |
| 内存隔离 | 进程间隔离,一个任务 OOM 不影响其他 | 共享堆,一个任务 OOM 可能拖垮 Executor |
| 数据共享 | 进程间只能通过网络/文件 | 可直接共享缓存与对象 |
线程级并行是 Spark 能「跑大量小任务」的前提:如果每个任务都启动 JVM,几万个任务光启动开销就不可接受。代价是隔离性下降——所以调优里要控制「每个 Executor 的核数」和「单任务内存」,避免一个胖任务把整个 Executor 拖下水。
作业生命周期的边界情况
生命周期在异常路径上更能说明问题:
| 边界情况 | 发生什么 | 谁来兜底 |
|---|---|---|
| 某 Task 失败 | 该 Task 重试,其他任务不受影响 | TaskScheduler(第 6 章) |
| 某 Stage 全部失败 | 重试耗尽 → Job 失败 | DAGScheduler |
| Executor 丢失 | 其任务重调度,缓存按血缘重算 | SchedulerBackend |
| Driver 丢失 | Job 直接失败,无自动恢复 | 外部编排重提交 |
| 结果太大 | collect 撑爆 Driver 内存 | 用户改用 saveAsTextFile |
最后一行是实践里最常见的坑:collect() 把全部结果拉回 Driver,数据量大时直接 OOM。正确做法是用行动把结果写到分布式存储(saveAsTextFile),只在结果很小时才 collect。生命周期的最后一环「结果回收」也有容量边界,这一点常被忽略。
部署模式:Client 与 Cluster
Driver 跑在哪里,决定了两种部署模式:
| 模式 | Driver 位置 | 适用 | 失败影响 |
|---|---|---|---|
| client | 提交机(如网关) | 交互式、笔记本调试 | 提交机断连 → 作业失败 |
| cluster | 集群内某节点 | 生产批作业 | Driver 节点故障 → 作业失败 |
client 模式下 Driver 在集群外,结果直接回显在终端,适合探索;cluster 模式下 Driver 在集群内,提交后客户端可以断开,适合长作业。两种模式的共同点是:Driver 一失败,作业就得重来。
资源从哪来:与 Cluster Manager 的边界
Spark 自己不管物理资源,它向 Cluster Manager 要「一组 Executor」。三种常见后端:
| 后端 | 资源单位 | 特点 |
|---|---|---|
| Standalone | Executor 进程 | Spark 自带,简单 |
| YARN | 容器 | 与 Hadoop 生态共享集群(卷一第 10 章) |
| Kubernetes | Pod | 云原生,弹性好(卷四展开) |
Driver 向 Cluster Manager 申请 Executor,Cluster Manager 决定「给几台、每台多少核多少内存」。这个边界很重要:Spark 决定「怎么用资源」,Cluster Manager 决定「给多少资源」。动态分配(第 11 章)就是在这个边界上做文章——根据待处理任务数申请或释放 Executor。
Driver 控制面与 Executor 执行面
Driver 中的两个调度器负责阶段与任务,集群管理器控制资源。数据块和 shuffle 数据在执行侧流动。
flowchart LR
subgraph Driver
U[应用代码] --> D[DAGScheduler]
D --> T[TaskScheduler]
end
T -->|任务和状态| E[Executor]
M[集群管理器] -->|分配进程资源| E
E --> B[(BlockManager 与 shuffle 文件)]
B -->|读分区结果| F[其他 Executor]
三个常见误解
误解一:Executor 越多越快。 真相:Executor 数受数据分区数与集群资源限制,过多会让调度开销与 shuffle 开销上升。吞吐的瓶颈常在 shuffle 与磁盘,不在核数。
误解二:Driver 只是个提交客户端。 真相:Driver 承担全部规划与调度,内存里装着血缘图和任务状态,是作业的真正大脑,也是单点。
误解三:任务失败等于作业失败。 真相:Task 失败会重试(第 6 章),Executor 失败会重调度。只有 Driver 失败,或重试次数耗尽,作业才失败。
一句话总结本节
Spark 是「中心规划 + 边缘执行」:Driver 持有血缘与调度逻辑,把一次行动拆成 Job → Stage → Task 并分发;Executor 以线程级并行执行任务、缓存分区、提供 shuffle 数据;Cluster Manager 只负责供货。三层结构里,Stage 数由宽依赖决定、Task 数由分区决定、并发数由槽位决定;失败语义上 Executor 可替换、Driver 是单点——这也是批处理作业「可整体重跑」这一假设的直接来源。
本节 lab
下载 bd-spark-lab 源码 · 实验运行与版本说明
在 bd-spark-lab/ 中复现架构与生命周期的数量关系:
- 源码:
src/rdd/RddCore.java(parallelism / tasks)、src/dag/DagPlanner.java(countStages / stageOf)与对应的RddSuite、DagSuite。 - 运行:
javac -d out $(find src -name '*.java') && java -cp out lab.RunAll。 - 断言:
RddSuite用例 12 验证「并行度受槽位限制」;DagSuite用例 1-3 验证「线性变换链的阶段数 = 宽依赖数 + 1」,用例 9 验证「任务数 = 分区数」。 - 整卷 runner 的预期汇总为
TOTAL: 109 passed, 0 failed。
对应本节判断链:一次行动 → 一个 Job → 按宽依赖切 Stage → 每 Stage 按分区出 Task → 按槽位并发——lab 里的阶段计数与任务计数就是这条链的前半段。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。