罗罗编程学习记录
本页内容 展开查看

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(自适应查询执行)