《大规模分布式计算深入解析》1.2 惰性求值与血缘(lineage)

变换只记录「怎么算」,行动才触发计算——惰性求值是 Spark 把多个变换合并成一条流水线的前提。血缘(lineage)记录每个 RDD 从哪些父 RDD 来、用什么函数算,构成无需元数据服务的恢复路径;检查点则截断血缘。lab 复现惰性判定、重算计数与血缘截断。

1.2 惰性求值与血缘(lineage)

1.1 说 RDD 容错靠「不可变 + 血缘」:数据丢了,沿着父指针重算。这一节把两个问题讲透:变换为什么不在写下的那一刻执行(惰性求值),血缘到底记录了哪些信息(血统)。理解这两点,才能理解 Spark 为什么能在一个作业里把十几个变换合并成一条流水线,而不是每步都物化。

两类操作:变换与行动

Spark 的操作分成两类,边界非常清晰:

类型例子返回是否触发计算
变换(transformation)map / filter / join / groupByKey新 RDD否,只记录血缘
行动(action)collect / count / saveAsTextFile / take具体值或副作用是,触发作业

用户写下的 filter、map 只是往血缘图里加了一个节点;只有 count()、collect() 这样的行动,才会让引擎回头遍历血缘、生成任务、真正开始读数据。

lab 的 Lineage.triggersJob("transform") 返回 false、triggersJob("action") 返回 true(用例 13-14)——这就是惰性的最小判据:看操作类型,不看操作位置。

惰性求值换来了什么

惰性不是为了「省一行代码」,它换来三样东西:

收益机制效果
全链路优化看到完整的变换链再规划合并流水线,减少物化
避免无用计算只算行动需要的数据如 take(10) 只算前几个分区
减少中间写窄依赖链可整段流水线十几个 map 合并成一次遍历

第一条最关键。假设用户写了 filter → map → filter → map 四个变换,如果每个变换都立即执行,就要物化三份中间 RDD;惰性求值让引擎看到完整的四步链,把能在同一次遍历里做的操作合并,只在最后真正需要时算一遍。惰性是优化的前提——看不见全貌,就谈不上重排与合并。

血统:恢复路径的数据结构

血统不在中心化的元数据服务里,而是嵌在每个 RDD 对象里:每个 RDD 记着自己的父 RDD(一个或多个)和变换函数。丢失分区时,引擎沿着这些指针回溯,直到找到可用的缓存分区或原始数据。

rdd3(reduceByKey) → rdd2(map) → rdd1(filter) → rdd0(textFile)
丢失 rdd3.p5:
  看 rdd2 的哪些分区有缓存 → 没有则继续回溯
  到 rdd0 读对应分片 → 依次重放 filter/map → 得到 rdd3.p5

这段回溯过程有一个重要性质:它不需要任何全局信息。每个节点只知道自己与父节点的关系,恢复完全靠局部指针。这让血统在「调度器短暂失联」「部分节点重启」时依然可用——只要 RDD 对象还在 Driver 内存里,路径就在。

血缘重算的范围:只补丢失的部分

血统最重要的工程价值,是把「恢复」的范围压到最小:

MR:一个任务失败 → 整个分片重跑
RDD:一个分区丢失 → 只重算这一个分区
     若祖先分区有缓存 → 重算成本接近 0

lab 的 Lineage.recomputeCount(cached, lost) 复现了这个判断:4 个分区里丢了 3 个,其中 1 个已缓存,真正需要重算的只有 2 个(用例 15);如果 4 个分区全部已缓存,重算数为 0(用例 16)。缓存覆盖的部分不重算、血统知道剩下的怎么重算——这是 15.3 讲过的「血缘重算」在 RDD 层的直接实现。

血缘 vs DAG:一张图的两种读法

「血缘」和「DAG」经常被混用,它们其实是同一张图的两种读法:

视角回答的问题使用者方向
血缘(lineage)这个分区从哪来、怎么算容错恢复从子到父回溯
DAG(有向无环图)这批计算按什么顺序跑调度器从父到子推进

血统强调的是「每个 RDD 节点记着自己的来源」,是一种数据结构;DAG 强调的是「整张图的依赖关系与执行顺序」,是一种调度视图。同一条依赖边,在血统里是「重算的父指针」,在 DAG 里是「任务的前置条件」。

这个区分在工程上很重要:血统可以是局部的(一个 RDD 只知道自己的父),DAG 必须是全局的(调度器要看到整个作业的依赖)。所以 Spark 在 Executor 侧只传任务与依赖元数据,真正的全局 DAG 始终留在 Driver 里。第 3 章的 DAG 调度器,就是把这张全局图切成一棵棵可并行执行的子树。

惰性求值下的资源规划

惰性不是「什么都不做」,而是把「规划」和「执行」分开。规划阶段能做的事,比逐条执行时多得多:

规划动作逐条执行时惰性规划时
合并窄依赖每个变换一次遍历整段链一次遍历
裁剪无用分支先算了才发现不用没被 action 引用的分支直接不排
选择 join 策略已到执行期,只能按默认可看两侧统计信息再定(第 8 章)
决定分区数每步固定可在 shuffle 前统一调整

最后一条尤其关键:分区数可以在规划期统一决定。如果每写一个变换就执行一次,分区数只能一步步继承、无法回头调整;惰性规划让引擎在「看到完整链路」之后再定分区与并行度,这也是第 12 章「分区调优」能生效的前提。

血缘追踪的一个可复现例子

把 1.1 的例子再走一遍恢复路径,看清每一步读的是哪份信息:

目标:重建 rdd3 的分区 5
1. rdd3 记着父 RDD = rdd2,分区器为 hash(userId) % 8
2. 查分区器 → 找 rdd2 中所有可能落到分区 5 的父分区
3. rdd2 某父分区已缓存 → 直接读,不再回溯
4. 未缓存的父分区 → 继续查 rdd2 的父(rdd1)
5. 直到 rdd0 的输入分片 → 读 HDFS 块 → 逐层重放函数

整个过程中,引擎只读血缘、不看数据:分区器告诉你「哪些父分区可能有贡献」,缓存状态告诉你「哪里可以停下」。数据本身只在最后一步重放时才被读取。这就是「恢复路径是数据自带的」的具体含义。

链式重算的成本

血统是一棵树(严格说是 DAG),重算成本取决于回溯的深度。若一个分区要经过 3 层窄依赖才能算出来,重算成本就是 3 次函数调用(外加可能的读数据)。

lab 的 Lineage.chainCost(3) 返回 3(用例 19)——这是简化模型,但抓住了本质:血缘越深,重算越贵。这也是为什么长时间运行的作业需要检查点:血缘会随变换不断变长。

检查点:截断血缘

如果一个 RDD 的血缘链有几十层,分区丢失时重算会非常昂贵。检查点(checkpoint)把当前 RDD 物化到可靠存储,并把血统「剪断」:

状态血缘深度分区丢失后的恢复
无检查点5 层回溯 5 层重算
有检查点1 层直接从检查点读回
有检查点 + 缓存1 层从缓存或检查点读,0 次重算

lab 的 Lineage.effectiveDepth(5, true) 返回 1、effectiveDepth(5, false) 返回 5(用例 17-18);recoverFromCheckpoint(lost, true) 返回 0(用例 20)。检查点的本质是「用一次写盘换掉整条血统」:写盘有成本,但它把未来的重算成本从「链长」压到「0」。

检查点与缓存的区别也在这里:缓存保留血缘(缓存丢了还能重算),检查点截断血缘(数据已落到可靠存储,不再需要重算)。所以长血缘的迭代作业,常见做法是「缓存用于加速、检查点用于兜底」。

血统的边界:它不记录什么

血统也不是万能的,它明确不记录三类信息:

不记录后果兜底手段
数据内容的校验缓存被静默篡改无法发现校验和 / 存储层校验
外部系统的副作用写数据库的重复执行幂等写 / 事务(7.3)
随机种子之外的执行环境依赖外部状态的 UDF 不可重放让 UDF 纯函数化

血统承诺的是「同样的父数据 + 同样的函数 → 同样的结果」。一旦计算依赖了外部可变状态(时间、随机数、外部服务),这个承诺就失效了。这不是 Spark 的缺陷,而是「重算」这一恢复模型的固有边界——卷三 Flink 的检查点之所以要连「状态」一起存,正是因为它面对的是有状态的流计算。

惰性与血统的配合

两个机制经常被分开讲,其实它们是一套组合:

惰性:先不执行,攒成一张血缘图
血统:图留着,既用于「什么时候算」,也用于「丢了怎么算」
  • 正向:行动触发时,沿血缘图做 DAG 划分与流水线合并(第 3 章)。
  • 反向:分区丢失时,沿同一张图回溯重算(第 7 章)。

同一张图,两个方向。惰性让图存在,血统让图有用。理解了这一点,后面 DAG 调度器、Stage 划分、容错重算,都是这张图的不同用法,不是新东西。

三个常见误解

误解一:惰性求值 = 延迟执行,性能一定更好。 真相:惰性换来优化空间,但调试时栈追踪难、错误延迟暴露。对交互式探索,适时的行动(如 count())反而帮助定位问题。

误解二:血统会无限增长,最终拖垮 Driver。 真相:血统随变换增长,但长作业会用检查点截断;且血缘只是轻量指针,真正的成本在重算,不在存储。

误解三:有缓存就不需要血统。 真相:缓存会丢(节点故障、内存回收),血统是缓存失效后的兜底。只有检查点能真正替代血统,因为它把数据落到了可靠存储。

一句话总结本节

变换只记录、行动才计算——惰性求值让引擎看到完整变换链再规划,是流水线合并与按需计算的前提;血统把「每个 RDD 从哪些父 RDD、用什么函数来」嵌进 RDD 自身,构成无需全局元数据的恢复路径,让分区丢失只重算丢失部分、缓存覆盖的部分零重算;血缘越深重算越贵,检查点用一次写盘截断血缘——同一张血缘图,正向用于调度,反向用于恢复。

本节 lab

下载 bd-spark-lab 源码 · 实验运行与版本说明

在 bd-spark-lab/ 中复现惰性与血统:

  • 源码:src/rdd/Lineage.java(triggersJob / recomputeCount / effectiveDepth / chainCost / recoverFromCheckpoint)与 src/rdd/RddSuite.java。
  • 运行:javac -d out $(find src -name '*.java') && java -cp out lab.RunAll。
  • 断言:RddSuite 用例 13-14 验证惰性(变换不触发、行动触发);用例 15-16 验证「丢失 3 分区、1 缓存 → 只重算 2」「全缓存 → 0」;用例 17-20 验证检查点截断血缘与零重算。
  • 整卷 runner 的预期汇总为 TOTAL: 109 passed, 0 failed。

对应本节判断链:变换只记录 → 行动才计算 → 血统记恢复路径 → 只重算丢失分区 → 检查点截断血缘——Lineage 的八个用例就是这条链的逐环验证。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图