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 | 变换 | 依赖类型 |
|---|---|---|---|
| rdd1 | rdd0 | filter | 窄(一对一) |
| rdd2 | rdd1 | map | 窄(一对一) |
| rdd3 | rdd2 | reduceByKey | 宽(需 shuffle) |
当 rdd3 的某个分区丢失时,重算路径是:查 rdd3 的父分区(可能涉及多个 rdd2 分区,因为宽依赖)→ 若 rdd2 有缓存则直接取 → 否则回溯到 rdd1、rdd0 重算。血缘把「怎么恢复」变成了「沿着父指针走一遍」,不需要任何中心化的元数据服务。
这也是 RDD 相对 MR 的一个隐性优势:恢复路径是数据自带的。MR 的任务失败后,调度器只知道「重跑这个 split」;RDD 的分区丢失后,引擎知道「重算这个分区需要哪些父分区、可以复用哪些缓存」。恢复的粒度与信息量都更细。
抽象抬升带来的三个新问题
RDD 解决了 MR 的中间结果问题,同时引入了三个新问题——它们正是卷二后续章节的主题:
| 新问题 | 表现 | 卷二对应章节 |
|---|---|---|
| 惰性求值 | 变换不立即执行,何时算、算多少要规划 | 1.2 惰性求值与血统 |
| 依赖分类 | 窄依赖可流水线,宽依赖要 shuffle | 2.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「中间结果必落盘、任务无共享」的短板,用「不可变 + 血缘」把容错从整个任务重放细化到丢失分区重算——「弹性」指的是丢失部分可由血缘重建,而不是性能或资源的弹性。
本章实现对照
本节 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 的前四个用例就是这一层抽象的最小验证。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。