09.10.1 Spark 架构与执行模型
所属:全栈开发面试题库 / 09 高阶架构:高并发与分布式 / 09.10 大数据与流处理
覆盖范围
- RDD、DAG、宽窄依赖
- Stage 划分与 Shuffle
- Spark 作业执行流程
- 内存管理与缓存
- Spark on YARN/K8s 部署模型
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 09.10.1-001 | RDD 是什么 | 基础 | ★★★★☆ |
| 09.10.1-002 | 宽窄依赖有什么区别 | 进阶 | ★★★★★ |
| 09.10.1-003 | Stage 怎么划分 | 进阶 | ★★★★★ |
| 09.10.1-004 | Shuffle 是什么,代价是什么 | 进阶 | ★★★★★ |
| 09.10.1-005 | Spark 作业执行流程 | 进阶 | ★★★★☆ |
| 09.10.1-006 | DAG Scheduler 做什么 | 进阶 | ★★★☆☆ |
| 09.10.1-007 | RDD 缓存和持久化 | 基础 | ★★★★☆ |
| 09.10.1-008 | Spark 内存管理 | 进阶 | ★★★☆☆ |
| 09.10.1-009 | Spark on YARN 部署 | 进阶 | ★★★☆☆ |
| 09.10.1-010 | Spark 与 MapReduce 区别 | 基础 | ★★★★☆ |
09.10.1-001 RDD 是什么?
一句话结论
RDD(Resilient Distributed Dataset)是 Spark 的核心抽象:一个不可变、分区、可并行计算的数据集;RDD 记录血缘关系(lineage),分区丢失时可从血缘重建,不需要每次都物化数据;它是 Spark 早期的核心模型,DataFrame/Dataset 是在 RDD 之上的优化层。
概念解释
- 不可变:RDD 创建后不能修改,转换操作产生新 RDD。
- 分区:数据分片,每个分区在一个 Task 上计算。
- 血缘:RDD 记录依赖链,分区丢失时从血缘重建。
- 容错:通过血缘重建,不需要复制数据。
原理流程
RDD 操作:
转换(map/filter):惰性,产生新 RDD,不执行
行动(count/collect):触发 DAG 执行
代码或图示
lines = sc.textFile("hdfs://input") # RDD 1
errors = lines.filter(lambda l: "ERROR" in l) # RDD 2
errors.count() # 行动,触发执行
常见误区
- 误区:RDD 是分布式数组。它是数据集 + 血缘 + 分区的抽象,不只是数据。
- 误区:RDD 每次转换都物化数据。转换是惰性的,只有行动才触发计算,中间 RDD 不物化。
追问
- 问:DataFrame 和 RDD 区别?答:DataFrame 有 schema,Catalyst 优化器优化执行计划,性能更好。
- 问:RDD 容错怎么实现?答:血缘重建,分区丢失时从父 RDD 重算该分区。
09.10.1-002 宽窄依赖有什么区别?
一句话结论
窄依赖是一个子 RDD 分区只依赖父 RDD 的一个分区(map/filter),可以流水线计算;宽依赖是一个子分区依赖父 RDD 的多个分区(groupByKey/reduceByKey),需要 Shuffle,所有父分区要计算完才能算子分区。
概念解释
- 窄依赖:1:1 或 N:1(子分区依赖一个父分区),流水线执行。
- 宽依赖:N:M(子分区依赖多个父分区),需要 Shuffle。
- Shuffle 边界:宽依赖是 Stage 划分点。
原理流程
窄依赖:
map → filter → 同一条流水线,一个分区算完
宽依赖:
groupByKey → 所有父分区 shuffle 到子分区
代码或图示
窄依赖:
parent[0] → child[0]
parent[1] → child[1]
宽依赖:
parent[0] ─┐
parent[1] ─┼→ child[0]
parent[2] ─┘ child[1]
常见误区
- 误区:reduceByKey 是窄依赖。reduceByKey 有 combine 阶段(map 端预聚合),但最终仍有 Shuffle,是宽依赖。
- 误区:join 是窄依赖。join 通常是宽依赖(除非广播 join)。
追问
- 问:哪些操作是窄依赖?答:map、filter、union、mapPartitions。
- 问:哪些操作是宽依赖?答:groupByKey、reduceByKey、join、distinct、repartition。
09.10.1-003 Stage 怎么划分?
一句话结论
Spark 从后往前(从行动操作开始)回溯 DAG,遇到宽依赖就切分 Stage;每个 Stage 内是连续的窄依赖流水线;宽依赖处是 Shuffle 边界,前一个 Stage 的输出 Shuffle 到后一个 Stage 的输入;Stage 数 = 宽依赖数 + 1。
概念解释
- DAG:RDD 依赖图。
- Stage:连续窄依赖组成的执行段。
- Shuffle 边界:宽依赖处切分。
原理流程
从行动操作回溯:
RDD3 (宽依赖) → RDD2 → RDD1
→ 遇到宽依赖切分
→ Stage 1: RDD1 → RDD2(窄依赖流水线)
→ Stage 2: RDD2 → RDD3(Shuffle 后)
代码或图示
example:
textFile → map → filter → groupByKey → count
Stage 1: textFile → map → filter(窄依赖)
Shuffle: filter 输出按 key 分桶
Stage 2: groupByKey → count(Shuffle 后)
常见误区
- 误区:Stage 数等于操作数。Stage 按宽依赖切分,连续窄依赖在一个 Stage 内。
- 误区:Stage 是并行单位。Task 才是并行单位,Stage 由多个 Task 组成。
追问
- 问:一个 Stage 有多少 Task?答:等于最后一个 RDD 的分区数。
- 问:Shuffle 读写在哪?答:前一个 Stage 写 Shuffle 文件,后一个 Stage 读 Shuffle 文件。
09.10.1-004 Shuffle 是什么,代价是什么?
一句话结论
Shuffle 是把数据按 key 重新分发到不同分区的过程:map 端把数据按 key 分桶写到磁盘,reduce 端拉取对应桶的数据;代价是磁盘 IO、网络 IO、序列化、内存开销,是 Spark 性能瓶颈的主要来源。
概念解释
- Map 端:分区按 key 哈希到 Shuffle 桶,写磁盘。
- Reduce 端:拉取对应桶的数据,聚合。
- 代价:磁盘写 + 网络 + 磁盘读,比内存计算慢几个数量级。
原理流程
Map 阶段:
每个分区 → 按 key hash → 写入 Shuffle 文件(每 reduce 一个文件)
Shuffle 阶段:
Reduce 拉取各 map 节点对应桶的数据
→ 聚合
代码或图示
Shuffle 代价:
- 磁盘:map 端写、reduce 端读
- 网络:跨节点传输
- 序列化:数据要序列化
- 内存:reduce 端聚合占内存
常见误区
- 误区:Shuffle 是网络传输。它包括 map 端写磁盘、网络传输、reduce 端读磁盘,全链路代价。
- 误区:Shuffle 可以完全避免。宽依赖操作必须 Shuffle,只能优化(map 端预聚合)。
追问
- 问:怎么减少 Shuffle?答:用 map 端预聚合(reduceByKey 代替 groupByKey)、广播 join、避免不必要的 Shuffle。
- 问:Shuffle 服务?答:External Shuffle Service 管理 Shuffle 文件,支持动态资源分配。
09.10.1-005 Spark 作业执行流程是什么?
一句话结论
作业提交后,DAG Scheduler 把 DAG 切分成 Stage,按顺序提交 Stage;每个 Stage 生成 TaskSet,Task Scheduler 把 Task 分配到 Executor 上执行;Executor 在集群节点上跑 Task,Shuffle 数据通过磁盘和网络传输;Stage 全部完成后作业结束。
概念解释
- DAG Scheduler:切分 Stage,提交 TaskSet。
- Task Scheduler:分配 Task 到 Executor。
- Executor:集群节点上的 JVM,跑 Task。
原理流程
1. 客户端提交作业(行动操作)
2. DAG Scheduler 从后往前切分 Stage
3. 按顺序提交 Stage(前一个 Stage Shuffle 完成才能跑下一个)
4. Task Scheduler 把 Task 分配到 Executor
5. Executor 跑 Task,Shuffle 写磁盘
6. 所有 Stage 完成 → 作业结束
代码或图示
Driver:
DAG Scheduler + Task Scheduler
Executor:
Task 执行 + 内存存储 + Shuffle 读写
常见误区
- 误区:Driver 执行计算。Driver 是调度器,计算在 Executor 上跑。
- 误区:Stage 并行执行。有 Shuffle 依赖的 Stage 按顺序执行,没有依赖的 Stage 可以并行。
追问
- 问:Driver 挂了怎么办?答:Driver 高可用(Spark Standalone/YARN),恢复时从 checkpoint 重算。
- 问:Task 失败怎么办?答:Task 自动重试,Stage 失败时 DAG Scheduler 重新提交失败 Stage。
09.10.1-006 DAG Scheduler 做什么?
一句话结论
DAG Scheduler 负责把 RDD DAG 切分成 Stage,按依赖顺序提交 Stage;它维护每个 Stage 的状态(等待、运行、失败),Shuffle 数据可用时触发下游 Stage;它是 Spark 作业调度的核心。
概念解释
- Stage 切分:从后往前,宽依赖处切分。
- Stage 提交:前一个 Stage Shuffle 完成,提交下一个 Stage。
- 失败恢复:Stage 失败时重新提交。
原理流程
DAG Scheduler:
1. 接收作业提交
2. 切分 Stage
3. 提交第一个 Stage(没有 Shuffle 依赖的)
4. Stage 完成后,检查下游 Stage 的 Shuffle 依赖是否就绪
5. 就绪则提交下游
代码或图示
Stage 状态:
WAITING → RUNNING → SUCCESS/FAILED
常见误区
- 误区:DAG Scheduler 分配 Task 到节点。Task Scheduler 负责分配,DAG Scheduler 只管 Stage 切分和提交。
- 误区:DAG Scheduler 一次提交所有 Stage。它按 Shuffle 依赖顺序提交,下游 Stage 等上游 Shuffle 完成。
追问
- 问:FAIR 调度?答:DAG Scheduler 支持 FIFO 和 FAIR 调度,多个作业共享集群资源。
- 问:Speculative Execution?答:慢 Task 启动备份 Task,Task Scheduler 负责。
09.10.1-007 RDD 缓存和持久化有什么区别?
一句话结论
cache() 是 persist(MEMORY_ONLY) 的简写,把 RDD 缓存在内存;persist() 可以指定存储级别(内存、磁盘、内存+磁盘、序列化);缓存用于多次复用的 RDD,避免重算;不缓存的 RDD 每次行动都从血缘重算。
概念解释
- cache():内存缓存,等价于 persist(MEMORY_ONLY)。
- persist(level):指定存储级别,例如 MEMORY_AND_DISK。
- unpersist():手动移除缓存。
原理流程
rdd.cache() # 标记缓存
rdd.count() # 第一次计算,结果缓存
rdd.count() # 第二次直接读缓存,不重算
代码或图示
存储级别:
MEMORY_ONLY:纯内存
MEMORY_AND_DISK:内存不够溢写磁盘
MEMORY_ONLY_SER:序列化,省内存但慢
常见误区
- 误区:cache() 立即执行。cache() 是标记,第一次行动时才缓存。
- 误区:缓存永远留在内存。LRU 策略,内存不够时自动淘汰旧缓存。
追问
- 问:什么时候缓存?答:一个 RDD 被多个行动复用,且计算代价高时。
- 问:缓存和 checkpoint 区别?答:缓存在内存/磁盘,血缘还在;checkpoint 写到可靠存储,切断血缘。
09.10.1-008 Spark 内存管理是怎样的?
一句话结论
Spark Executor 内存分为:Execution 内存(Shuffle、join、sort 计算用)、Storage 内存(缓存 RDD)、User 内存(用户数据结构)、Reserved 内存(预留);Execution 和 Storage 可以互相借用(Storage 可被 Execution 驱逐),是统一内存管理。
概念解释
- Execution:计算内存,Shuffle/join/sort 用。
- Storage:缓存内存,存 RDD 块。
- 借用:Storage 内存不够时,Execution 可借用;Execution 需要时驱逐 Storage 缓存。
原理流程
Executor 内存:
Reserved 300MB
User 25%
Execution + Storage 75%(动态共享)
代码或图示
统一内存:
Execution ←→ Storage
Execution 需要更多 → 驱逐 Storage 缓存
Storage 需要更多 → 只能用 Execution 空闲部分
常见误区
- 误区:缓存占满内存就 OOM。Storage 内存不够时溢写磁盘(MEMORY_AND_DISK)。
- 误区:Execution 和 Storage 完全隔离。它们共享 75% 内存,动态借用。
追问
- 问:怎么调内存?答:spark.executor.memory 设总量,spark.memory.fraction 设 Execution+Storage 比例。
- 问:OOM 怎么排查?答:看是 Execution OOM(数据倾斜)还是 Storage OOM(缓存太多)。
09.10.1-009 Spark on YARN 部署模型是什么?
一句话结论
Spark on YARN 有两种部署模式:client 模式(Driver 在提交作业的客户端,结果直接返回客户端)和 cluster 模式(Driver 在 YARN 容器里,提交后客户端断开);ApplicationMaster 在 cluster 模式下就是 Driver。
概念解释
- Client 模式:Driver 在客户端,适合交互式调试。
- Cluster 模式:Driver 在集群内,适合生产作业。
- ApplicationMaster:YARN 中管理作业的容器,cluster 模式下是 Driver。
原理流程
Cluster 模式:
1. 客户端向 YARN 申请 AM 容器
2. AM(Driver)启动,申请 Executor 容器
3. Executor 启动,跑 Task
4. 客户端断开,作业在集群内跑
代码或图示
Client 模式:
Driver 在客户端,AM 只申请资源
Cluster 模式:
Driver 在 AM 容器里
常见误区
- 误区:client 模式生产可用。client 模式 Driver 在客户端,客户端挂了作业就挂,生产用 cluster。
- 误区:Driver 是 Executor。Driver 是调度器,Executor 是 Worker 上的计算进程。
追问
- 问:Spark on K8s?答:Spark 3.x 支持 K8s 作为资源管理器,Driver 和 Executor 都是 Pod。
- 问:动态资源分配?答:根据负载自动增减 Executor,需要 External Shuffle Service。
09.10.1-010 Spark 与 MapReduce 有什么区别?
一句话结论
MapReduce 每个阶段都落磁盘,中间结果写 HDFS,慢;Spark 基于内存,中间结果在内存中,DAG 流水线执行,比 MR 快 10~100 倍(迭代计算场景);但 Spark 仍通过 Shuffle 落磁盘,不是纯内存计算。
概念解释
- MR:Map → Shuffle → Reduce,每阶段落磁盘。
- Spark:内存计算,DAG 流水线,中间结果在内存。
- 速度:迭代计算(机器学习、图计算)Spark 远快于 MR。
原理流程
MR:
Map → 写磁盘 → Shuffle → 写磁盘 → Reduce
每步都磁盘 IO
Spark:
窄依赖流水线在内存
宽依赖 Shuffle 才落磁盘
代码或图示
对比:
MR:每阶段落磁盘,容错靠重算
Spark:内存 + DAG,Shuffle 落磁盘
常见误区
- 误区:Spark 完全内存计算。Shuffle 仍落磁盘,窄依赖流水线在内存。
- 误区:Spark 一定比 MR 快。简单批处理差异不大,迭代计算场景 Spark 优势明显。
追问
- 问:Spark 为什么比 MR 快?答:中间结果在内存、DAG 流水线减少 Shuffle 次数、线程模型(比 MR 进程模型轻)。
- 问:MR 还有用吗?答:现有 Hadoop 集群仍在用,新作业多用 Spark 或 Flink。
待整理清单
- [ ] Spark 性能调优参数清单
- [ ] Shuffle 调优(sort/shuffle/hash shuffle)
- [ ] Spark 3.x AQE(自适应查询执行)