深色模式
02 · Spark 原理:同样是分布式计算,为什么快
学完你能说出:
- RDD、懒执行、DAG、血缘容错分别是什么。
- 窄依赖和宽依赖的区别,Stage 在哪里切,Job / Stage / Task 的关系。
- cache 和 checkpoint 的区别,Driver 和 Executor 的分工,
local[2]和--master yarn的区别。
先看地图
上一篇讲了 MapReduce 为什么慢。Spark 的计算模型和它一样(分区并行 + Shuffle 汇总),但做了几个关键改进。本篇讲 6 个点:
① RDD 是什么 → ② 懒执行和 DAG → ③ 宽窄依赖与 Stage → ④ Job / Stage / Task → ⑤ 血缘容错、cache 和 checkpoint → ⑥ Driver、Executor 与运行模式
一句话本质
Spark 把计算写成一串变换,先画好整张流程图(DAG)再执行;同一个 Stage 里的步骤在内存里流水线跑完,只在必须重新分组(Shuffle)的地方才切开。
生活类比
做一桌菜:
- MapReduce:每做完一道工序(洗、切、炒)都把半成品装盒放进冰箱,下一道工序再从冰箱拿出来。
- Spark:先看完整份菜谱(DAG),能连着做的工序一口气做完(洗 → 切 → 腌,不进冰箱),只有需要把所有人的食材汇到一个锅里时(Shuffle)才停一下。
- 血缘容错:一盘菜打翻了,照着菜谱从原料重新做这一盘,不用整桌重做。
一步步看
1. RDD:分布在很多机器上的一个大列表
RDD(Resilient Distributed Dataset,弹性分布式数据集):一个被切成多个分区、分散在不同机器上的只读数据集合。
scala
val lines = sc.textFile("hdfs:///logs/2026-11-20") // 读文件,比如 3 个分区
val words = lines.flatMap(_.split(" ")) // 每行拆成词
val pairs = words.map(w => (w, 1)) // 变成 (词, 1)
val counts = pairs.reduceByKey(_ + _) // 按词求和
counts.collect() // 把结果拉回来- 只读:每一步变换都生成一个新的 RDD,不修改旧的。
- 分区:一个分区由一个 Task 处理,分区数决定了并行度。
DataFrame / Dataset 是 RDD 之上带表结构(列名、类型)的版本,可以写 SQL,还能被优化器(Catalyst)自动优化;日常开发多用 DataFrame,但原理都建立在 RDD 上。
2. 懒执行和 DAG
算子分两类:
| 类型 | 例子 | 执行吗 |
|---|---|---|
| 转换(Transformation) | map、filter、flatMap、reduceByKey、join | 不执行,只记下「要做什么」 |
| 行动(Action) | collect、count、saveAsTextFile、show | 触发执行 |
上面的代码,前 4 行只是在画图,到 collect() 才真正开始算。整张图就是 DAG(Directed Acyclic Graph,有向无环图):节点是 RDD,边是变换。
懒执行的好处:拿到整张图以后,Spark 可以统一规划——把能合并的步骤合并成一个 Stage 流水线执行,跳过用不到的计算。
3. 宽依赖、窄依赖与 Stage
| 窄依赖 | 宽依赖 | |
|---|---|---|
| 定义 | 子 RDD 的每个分区只依赖父 RDD 的一个分区 | 子 RDD 的一个分区依赖父 RDD 的多个分区 |
| 例子 | map、filter、flatMap | reduceByKey、groupByKey、join(大多数情况)、repartition |
| 需要 Shuffle 吗 | 不需要 | 需要 |
| 坏了一个分区 | 只重算上游对应的那一个分区 | 要重算上游所有相关分区 |
Stage 的切分规则:从最后的 RDD 往前看,遇到宽依赖就切一刀。同一个 Stage 里全是窄依赖,可以流水线执行:一条数据读进来,连续经过 flatMap、map,不需要等别的分区,也不落盘。
4. Job、Stage、Task
| 层级 | 怎么产生 | 例子 |
|---|---|---|
| Job | 一个 Action 产生一个 Job | collect() 一次 = 1 个 Job |
| Stage | 一个 Job 按宽依赖切成多个 Stage | 词频统计 = 2 个 Stage |
| Task | 一个 Stage 里一个分区一个 Task | 第 1 个 Stage 有 3 个分区 → 3 个 Task |
算一下:输入 3 个分区,reduceByKey 设成 2 个分区,最后 collect():1 个 Job、2 个 Stage、3 + 2 = 5 个 Task。
5. 血缘容错、cache 与 checkpoint
血缘(Lineage):每个 RDD 都记着「我是从哪个 RDD、经过什么变换来的」。某台机器挂了,丢了 counts 的第 2 个分区,Spark 就顺着血缘把这个分区重算一遍,而不是把数据存多份。
| cache / persist | checkpoint | |
|---|---|---|
| 存在哪 | Executor 的内存(或内存 + 磁盘) | HDFS 等可靠存储 |
| 血缘 | 保留 | 截断(之后从 checkpoint 读,不再往前追) |
| 目的 | 为了快:同一个 RDD 要用多次,别每次都从头算 | 为了稳:血缘太长(比如迭代 100 轮),出错时重算代价太大 |
| 机器挂了 | 缓存丢失,按血缘重算 | 数据还在 HDFS 上 |
注意:Spark 默认不缓存。一个 RDD 被两个 Action 用到,如果不 cache,它会被算两遍。另外,Shuffle 的中间结果仍然会写到本地磁盘,「Spark 全在内存里算」是不准确的说法。
6. Driver、Executor 与运行模式
| 角色 | 几个 | 做什么 |
|---|---|---|
| Driver | 1 个 | 运行 main 方法,画 DAG、切 Stage、分配 Task、收集结果 |
| Executor | 很多个 | 在各台机器上真正执行 Task,缓存数据 |
| 集群管理器(YARN 等) | — | 给 Driver 和 Executor 分配资源 |
bash
spark-submit --master local[2] app.jar # 本机跑,开 2 个线程模拟 2 个并行度,开发调试用
spark-submit --master yarn app.jar # 提交到 YARN 集群,Executor 分布在很多台机器上同一份代码,换一个 --master 参数就能从本机搬到集群上,不用改代码。
collect() 的坑:它会把所有分区的数据拉回 Driver 这一台机器。结果有 50 GB 的话,Driver 内存直接撑爆(OOM,内存溢出)。大结果应该 saveAsTextFile 写回 HDFS,或者只 take(20) 看几行。
为什么这么设计
为什么 Spark 比 MapReduce 快?
- 问题:MapReduce 每一步都写磁盘,一个作业只能一轮 Map + Reduce,复杂分析要串多个作业反复读写 HDFS。
- 方案:懒执行先拿到整张 DAG,同一个 Stage 里的窄依赖在内存中流水线执行,只在 Shuffle 处落盘;一个程序可以串任意多个算子;需要复用的数据可以 cache 在内存里。
- 好处:磁盘读写大大减少,迭代计算(机器学习)尤其明显。
一句话答法
计算模型一样都是分区并行加 Shuffle,但 Spark 先生成整张 DAG,同一个 Stage 内流水线执行不落盘,只在宽依赖处 Shuffle;一个程序能串多个算子,还能把复用的数据缓存在内存里,所以比 MapReduce 快。
为什么要用血缘容错,而不是把每一步结果都存多份?
- 问题:每一步都存多份副本,写入量和网络传输会成倍增加,和「少落盘」的目标矛盾。
- 方案:只记下每个 RDD 是怎么算出来的(血缘),出错时重算丢失的分区。
- 好处:正常运行时几乎没有额外开销;只在出错时付出重算代价。窄依赖下只需重算一条线,代价很小。
一句话答法
存副本要额外写盘和传网络,血缘只记录「怎么算出来的」,平时零开销,出错时只重算丢失的分区,所以 Spark 用血缘容错。
为什么在宽依赖处切 Stage?
- 问题:宽依赖的下游分区要等上游所有分区都算完才能开始(要收齐每个分区里属于自己的那部分数据)。
- 方案:在这里切一刀,上一个 Stage 全部完成并把结果按键写好,下一个 Stage 再来拉取。
- 好处:Stage 内部可以放心流水线执行;Stage 之间的边界就是数据交换的边界,也是失败重试的单位。
一句话答法
宽依赖要等上游所有分区都完成才能开始,必须在这里交换数据,所以在宽依赖处切 Stage;Stage 内部全是窄依赖,可以流水线执行。
英文术语拆解
| 术语 | 拆开看 | 一句话意思 |
|---|---|---|
| RDD | Resilient 有弹性的 + Distributed 分布式 + Dataset 数据集 | 分区、只读、能按血缘重算的数据集 |
| DAG | Directed 有向 + Acyclic 无环 + Graph 图 | 计算流程图 |
| Lineage | 血统、谱系 | 血缘:RDD 是怎么一步步算出来的 |
| Transformation | Trans 转换 + formation 形成 | 转换算子,懒执行 |
| Action | 行动 | 行动算子,触发计算 |
| Driver | 驾驶员 | 指挥节点 |
| Executor | Execute 执行 + or 者 | 执行节点 |
| OOM | Out 超出 + Of + Memory 内存 | 内存溢出 |
面试怎么问
Q:Spark 为什么比 MapReduce 快?
两者的计算模型一样,都是分区并行加 Shuffle 汇总。区别是:Spark 懒执行,先生成整个 DAG 统一规划,同一个 Stage 内的窄依赖算子在内存里流水线执行、不落盘,只有宽依赖的 Shuffle 才写磁盘;一个程序可以串很多算子,不用像 MapReduce 那样拆成多个作业反复读写 HDFS;还可以把复用的数据 cache 在内存。
Q:什么是宽依赖和窄依赖?Stage 怎么划分?
窄依赖是子分区只依赖父 RDD 的一个分区,如 map、filter;宽依赖是子分区依赖父 RDD 的多个分区,需要 Shuffle,如 reduceByKey、groupByKey、join。从后往前遇到宽依赖就切一个 Stage,同一个 Stage 内可以流水线执行。
Q:cache 和 checkpoint 有什么区别?
cache 把数据存在 Executor 内存里,保留血缘,目的是同一个 RDD 被多次使用时不用重算,为了快;checkpoint 把数据写到 HDFS 并截断血缘,目的是血缘太长时出错不用从头重算,为了稳。通常先 cache 再 checkpoint,避免 checkpoint 时再算一遍。
Q:Job、Stage、Task 是什么关系?
一个 Action 触发一个 Job;一个 Job 按宽依赖切成多个 Stage;一个 Stage 里每个分区对应一个 Task。Task 是真正在 Executor 上执行的最小单位。
容易混的地方
- Spark 不是「全在内存里算」:Shuffle 中间结果仍然写本地磁盘;内存不够时缓存也会溢写。
- join 不一定是宽依赖:两个 RDD 已经按同样方式分好区时,join 是窄依赖。
- cache 本身也是懒的:调用
cache()不会立刻缓存,下一次 Action 计算时才存。 - local[2] 的 2 是线程数:不是机器数。
和其他知识的连接
- ← 来自 Hadoop:Map / Shuffle / Reduce 的模型和它为什么慢。
- → 影响 Spark 调优:Shuffle 是大部分性能问题的根源。
- → 影响 SQL 执行顺序与常见坑:Spark SQL / Hive SQL 最终也被翻译成这样的 DAG。
自测 3 问
Q1:读 4 个分区的文件,经过 map、filter,再 reduceByKey 到 2 个分区,最后 collect。有几个 Job、几个 Stage、几个 Task?
点开看答案
1 个 Job(一个 Action);2 个 Stage(reduceByKey 是宽依赖,切一刀);4 + 2 = 6 个 Task。
Q2:一个 RDD 先后被 count() 和 saveAsTextFile() 用到,没有 cache 会怎样?
点开看答案
两个 Action 各触发一个 Job,这个 RDD 会从源头完整算两遍。如果它的计算很贵,应该先 cache,第二次直接从内存读。
Q3:迭代 100 轮的算法,为什么要定期 checkpoint?
点开看答案
血缘会越来越长,某个分区丢失时要从第 1 轮重算到第 100 轮,代价极大,甚至可能栈溢出。checkpoint 把中间结果写到 HDFS 并截断血缘,出错时从 checkpoint 开始重算。
✅ 验收清单
- 能说出转换算子和行动算子的区别,各举 3 个例子
- 能画出词频统计的两个 Stage,并标出宽依赖的位置
- 能根据分区数算出 Job、Stage、Task 的个数
- 能对比 cache 和 checkpoint 的 4 个区别
- 能说出 Driver 和 Executor 的分工,以及 collect 大数据的风险
下一步该懂什么
- Shuffle 慢、数据倾斜怎么办 → Spark 调优