《大规模分布式计算深入解析》1.1 为什么需要 RDD(弹性分布式数据集)

卷二开篇:MapReduce 把计算做成可重放的任务,却把「中间结果」锁在磁盘上。RDD 把抽象从「任务」抬到「数据集」——分区、依赖、不可变、血缘、可缓存,五个特征共同回答了「迭代计算怎么既不落盘又不丢」。lab 用分区切分与并行度复现 RDD 的第一层抽象。

1.1 为什么需要 RDD(弹性分布式数据集)

卷一在 15.3 收口时留下了一个判断:内存计算的动机是内存与磁盘之间约 100 倍的量级差,乘以迭代轮数,就是 Spark 相对 MapReduce 的全部优势。但「中间结果留内存」不是一句口号,它需要一个新的数据抽象来承载:什么东西可以被缓存?缓存丢了怎么恢复?多个作业怎么共享同一份中间结果?

这个抽象就是 RDD(Resilient Distributed Dataset,弹性分布式数据集)。本节回答一个问题:为什么 MapReduce 的任务抽象不够用,RDD 又凭什么补上它。

从「任务」到「数据集」:抽象层级的抬升

MapReduce 的抽象单位是一次作业里的一个任务(task)。任务的输入是 HDFS 上的一个分片,输出是 HDFS 上的一个文件;任务与任务之间只通过磁盘上的文件发生关系。

MR 的抽象:
  split → task(map)→ 落盘 → task(reduce)→ 落盘
  作业之间只有「文件」这一种连接方式

RDD 的抽象单位是数据集(dataset):一份逻辑上分区、物理上可分散在多个节点的只读数据集合。作业不再是「一次任务」,而是「对数据集的一串变换」:

RDD 的抽象:
  rdd0 → transform → rdd1 → transform → rdd2 → action
  中间结果是 RDD,可以被缓存、被复用、被重新计算

抽象层级抬高一级,带来的第一个直接好处是中间结果有了「名字」。MR 里两个作业共享中间结果,办法是第一个作业把它写到 HDFS、第二个作业再读;RDD 里一行 cached = rdd.cache() 就完成了共享。名字的存在,让「复用」从存储层的约定变成了计算层的语言。

MapReduce 的三条硬约束

理解 RDD 的必要性,最好的办法是看 MapReduce 做不了什么。它对中间结果有三条硬约束:

约束表现代价
中间结果必须落盘map 输出写本地盘,reduce 输出写 HDFS每轮迭代都要完整读写磁盘
任务无共享状态任务之间不能传递内存对象无法复用中间结果
作业边界由用户划分多阶段要手工串成多个作业调度开销与磁盘中转层层叠加

这三条约束在单次 ETL里都可以忍受:一次扫描、一次落盘、结束。但在迭代计算(机器学习、图算法)里,每轮迭代都要把同一份数据重新读一遍、重新落一遍盘,磁盘 IO 成本随轮数线性增长。15.3 的 lab 已经算过这笔账:迭代 5 轮,缓存后成本 500、未缓存 50000——差 100 倍,且轮数越多差得越大。

RDD 的出发点很朴素:如果中间结果本来就要被下一轮读,为什么不在它还在内存里的时候直接留下来。要留下它,就需要一个能描述「这份数据是怎么算出来的、分布在哪里、丢了怎么重建」的对象——这就是 RDD。

RDD 的五个特征

一个 RDD 由五个属性定义,缺一个都不成立:

特征含义作用
分区集合数据被切成若干分区(partition)决定并行度与数据分布
依赖关系每个分区依赖哪些父分区决定血缘与重算路径
计算函数给定父分区,怎么算出子分区决定重算时做什么
分区器键值型 RDD 的分区规则(可选)决定 shuffle 后数据落在哪
优先位置每个分区最想被放在哪些节点(可选)决定调度时的数据本地性

前三个是必需的:没有分区就没有并行,没有依赖就没有血缘,没有计算函数就无法重算。后两个是可选优化:分区器让 shuffle 结果确定,优先位置让调度器知道该把任务发到哪台机器。

lab 的 RddCore.partition(100, 4) 复现了第一层抽象——分区:100 条记录切成 4 个分区,每区 25 条;换成 partition(10, 3),得到 [4, 3, 3],余数分给前面的分区(用例 1-2)。分区集合不是一个抽象名词,它就是「每个分区有多少条记录」这个具体的数组。

并行度由分区数决定

分区的意义在调度层才完全显现:一个分区对应一个任务,任务数不超过分区数。

lab 的 RddCore.parallelism(1000, 100) 得到 10——1000 条记录、每分区 100 条,就是 10 个分区、最多 10 个并行任务(用例 3)。parallelism(101, 100) 得到 2,因为不足一个分区也要占一个分区(用例 4)。

RddCore.tasks(partitions, slots) 则把「并行度上限」说清楚:100 个分区但只有 8 个执行槽位,实际并发就是 8(用例 12)。分区数决定「有多少活可以并行」,槽位数决定「同时能干多少活」,两者取小才是真实并行度。这个区分是后面调优(第 12 章)的基础:分区太少浪费核,分区太多调度开销压过收益。

不可变 + 血缘:容错的另一种解法

RDD 是只读的:一旦创建,内容不再改变;所有变换都产生新的 RDD。这个设计看似保守,却换来了容错上的极大简化。

因为 RDD 不可变,所以「重算」是安全的:给定同样的父 RDD,用同样的计算函数,必然得到同样的子 RDD。这就是 1.2 要展开的血缘(lineage)机制的基础:

分区丢失 → 查血缘 → 找到父分区 → 重算该分区

对比 MR 的重放:MR 丢失一个任务,整个任务从头重跑;RDD 丢失一个分区,只重算这一个分区(如果它的祖先分区还缓存着,重算成本甚至为零)。不可变是「可重算」的前提,血缘是「重算范围」的边界——两者合起来,把容错从「重放整个任务」细化到「重算丢失分区」。

「弹性」到底指什么

RDD 名字里的 Resilient(弹性),经常被误解成「性能弹性」或「资源弹性」。它指的是数据层面的弹性:分区丢失可以重建、部分缓存丢失不影响正确性、计算可以退回到磁盘甚至重算。

弹性的维度机制表现
分区丢失血缘重算只补丢失分区
内存不足持久化级别回退内存 → 内存+磁盘 → 磁盘
节点故障调度重试 + 重算任务迁移到新节点
数据倾斜重分区调整分区数/分区函数

所以「弹性」不是「什么都能扛」,而是**「丢失的部分可由剩余部分与血缘重建」**。这个定义比「高可用」更窄,也更精确:它承诺的是可重建性,不是零丢失。

RDD 与文件、表的区别

初学者容易把 RDD 当成「内存里的表」。两者的区别在于语义层级:

维度文件表RDD
数据形态字节流有 schema 的行分区的对象集合
计算方式外部程序读SQL 声明式函数式变换
容错副本事务日志血缘重算
缓存操作系统页缓存引擎缓存显式 persist
优化无优化器重写无(RDD 层不做优化)

RDD 是计算层的抽象:它不关心数据长什么样,只关心「怎么从父分区算出子分区」。这也是为什么后来 Spark 在 RDD 之上又加了 DataFrame/Dataset(第 8 章)——RDD 表达力强但优化空间小,声明式的表抽象才能让 Catalyst 重写计划。

理解这个分层很关键:RDD 是「可重算的分区集合」,不是「内存表」。把它当表用,会写出大量低效的手工优化代码;把它当「带血缘的中间结果容器」用,才用对了它的定位。

血缘长什么样:一个具体例子

抽象讲完,看一份具体的血缘。假设从日志文件出发,做三步变换:

rdd0 = sc.textFile("hdfs://logs/2026-11-15")   // 100 个分区
rdd1 = rdd0.filter(line -> line.contains("ERROR"))
rdd2 = rdd1.map(line -> parse(line).userId)     // 仍是窄依赖
rdd3 = rdd2.mapToPair(id -> (id, 1)).reduceByKey(+)  // 宽依赖

血缘不是一张全局图,而是每个 RDD 记着自己的父 RDD 与变换函数:

RDD父 RDD变换依赖类型
rdd1rdd0filter窄(一对一)
rdd2rdd1map窄(一对一)
rdd3rdd2reduceByKey宽(需 shuffle)

当 rdd3 的某个分区丢失时,重算路径是:查 rdd3 的父分区(可能涉及多个 rdd2 分区,因为宽依赖)→ 若 rdd2 有缓存则直接取 → 否则回溯到 rdd1、rdd0 重算。血缘把「怎么恢复」变成了「沿着父指针走一遍」,不需要任何中心化的元数据服务。

这也是 RDD 相对 MR 的一个隐性优势:恢复路径是数据自带的。MR 的任务失败后,调度器只知道「重跑这个 split」;RDD 的分区丢失后,引擎知道「重算这个分区需要哪些父分区、可以复用哪些缓存」。恢复的粒度与信息量都更细。

抽象抬升带来的三个新问题

RDD 解决了 MR 的中间结果问题,同时引入了三个新问题——它们正是卷二后续章节的主题:

新问题表现卷二对应章节
惰性求值变换不立即执行,何时算、算多少要规划1.2 惰性求值与血统
依赖分类窄依赖可流水线,宽依赖要 shuffle2.2 窄依赖与宽依赖
缓存管理缓存什么、缓存多少、内存不够怎么办2.3 持久化 / 5 内存管理

抽象每抬高一级,就多一层需要显式管理的复杂度。RDD 把「中间结果」变成一等公民,代价是「中间结果的生命周期」也要由引擎(和用户)来管。卷二前半段(第 1-7 章)基本都在回答这三个问题。

什么时候不该用 RDD

RDD 不是万能抽象,它的适用边界同样清楚:

场景用 RDD 合适吗原因
迭代机器学习合适中间结果复用收益最大
交互式查询合适同一份数据反复扫
复杂 ETL一般声明式表达更易优化
结构化聚合不合适DataFrame + Catalyst 更优
需要 ACID 的表不合适应交给数据湖表格式(卷四)

判断标准:如果计算是「对同一份数据反复做相似的变换」,RDD 的缓存与血缘就值;如果计算是「一次性的、可用 SQL 描述的」,RDD 就是不必要的底层。这也是卷二后半段(第 8-9 章)转向 DataFrame 的原因——不是 RDD 不好,而是不同问题需要不同层级的抽象。

三个常见误解

误解一:RDD 就是内存里的数据。 真相:RDD 是「分区 + 依赖 + 计算函数」的描述,数据可能在内存、磁盘,甚至根本没被算出来(惰性)。cache() 只是「标记可缓存」,真正物化发生在第一次行动时。

误解二:RDD 不可变所以不能修改数据。 真相:不可变指「已创建的 RDD 内容不变」,不是「不能变换」。每次变换都产生新 RDD,血缘记录「新 RDD 怎么从旧 RDD 来」——这正是重算的依据。

误解三:RDD 比 DataFrame 低级,所以应该淘汰。 真相:RDD 是 DataFrame 的执行底座(DataFrame 最终编译成 RDD 操作),也是表达任意 Java/Scala 逻辑的唯一入口。两者是分层关系,不是替代关系。

一句话总结本节

RDD 把分布式计算的抽象从「任务」抬到「数据集」:分区集合决定并行度、依赖关系与计算函数构成血缘、不可变保证重算安全、缓存让中间结果留内存;它补上 MapReduce「中间结果必落盘、任务无共享」的短板,用「不可变 + 血缘」把容错从整个任务重放细化到丢失分区重算——「弹性」指的是丢失部分可由血缘重建,而不是性能或资源的弹性。

本章实现对照

Spark 3.5.7 RDD 指南

本节 lab

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

在 bd-spark-lab/ 中复现 RDD 的分区抽象:

  • 源码:src/rdd/RddCore.java(partition / parallelism / dependency / canPipeline / memoryFootprint / tasks)与 src/rdd/RddSuite.java。
  • 运行:javac -d out $(find src -name '*.java') && java -cp out lab.RunAll。
  • 断言:RddSuite 用例 1-4 验证分区切分与并行度(100 条 4 分区 → 25;余数前置 → [4,3,3];向上取整);用例 12 验证「并行度受槽位限制」。
  • 整卷 runner 的预期汇总为 TOTAL: 109 passed, 0 failed。

对应本节判断链:抽象从任务抬到数据集 → 五个特征里前三个必需(分区/依赖/计算函数)→ 分区数决定并行度上限、槽位决定实际并发——RddCore 的前四个用例就是这一层抽象的最小验证。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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