Skip to content

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 ​

← 左右滑动看完整图 →Stage 1:窄依赖,流水线执行(不落盘)Stage 2:Shuffle 之后textFile分区 1分区 2分区 3flatMap分区 1分区 2分区 3map(词, 1)分区 1分区 2分区 3reduceByKey分区 1分区 2窄依赖:一对一,坏了只重算这一条线  宽依赖:多对多,需要 Shuffle → 切 Stage 的地方
一个词频统计任务:textFile → flatMap → map 都是窄依赖(每个分区只依赖上游一个分区),可以在一个 Task 里流水线执行;reduceByKey 是宽依赖(要从所有上游分区收数据,需要 Shuffle),在这里切出新的 Stage。一个 action(collect / save)触发一个 Job,一个分区对应一个 Task。
窄依赖宽依赖
定义子 RDD 的每个分区只依赖父 RDD 的一个分区子 RDD 的一个分区依赖父 RDD 的多个分区
例子map、filter、flatMapreduceByKey、groupByKey、join(大多数情况)、repartition
需要 Shuffle 吗不需要需要
坏了一个分区只重算上游对应的那一个分区要重算上游所有相关分区

Stage 的切分规则:从最后的 RDD 往前看,遇到宽依赖就切一刀。同一个 Stage 里全是窄依赖,可以流水线执行:一条数据读进来,连续经过 flatMap、map,不需要等别的分区,也不落盘。

4. Job、Stage、Task ​

层级怎么产生例子
Job一个 Action 产生一个 Jobcollect() 一次 = 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 / persistcheckpoint
存在哪Executor 的内存(或内存 + 磁盘)HDFS 等可靠存储
血缘保留截断(之后从 checkpoint 读,不再往前追)
目的为了快:同一个 RDD 要用多次,别每次都从头算为了稳:血缘太长(比如迭代 100 轮),出错时重算代价太大
机器挂了缓存丢失,按血缘重算数据还在 HDFS 上

注意:Spark 默认不缓存。一个 RDD 被两个 Action 用到,如果不 cache,它会被算两遍。另外,Shuffle 的中间结果仍然会写到本地磁盘,「Spark 全在内存里算」是不准确的说法。

6. Driver、Executor 与运行模式 ​

角色几个做什么
Driver1 个运行 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 内部全是窄依赖,可以流水线执行。

英文术语拆解 ​

术语拆开看一句话意思
RDDResilient 有弹性的 + Distributed 分布式 + Dataset 数据集分区、只读、能按血缘重算的数据集
DAGDirected 有向 + Acyclic 无环 + Graph 图计算流程图
Lineage血统、谱系血缘:RDD 是怎么一步步算出来的
TransformationTrans 转换 + formation 形成转换算子,懒执行
Action行动行动算子,触发计算
Driver驾驶员指挥节点
ExecutorExecute 执行 + or 者执行节点
OOMOut 超出 + 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 大数据的风险

下一步该懂什么 ​