《大规模分布式计算深入解析》2.2 窄依赖与宽依赖(narrow/wide)

窄依赖是「一个子分区只依赖固定的父分区」,宽依赖是「一个子分区依赖多个父分区」。这条区分线同时决定了三件事:能否流水线、是否要 shuffle、重算范围多大。本节把常见的窄/宽算子列清,并用 Stage 边界与恢复成本说明为什么它是 Spark 调度模型的分水岭。

2.2 窄依赖与宽依赖(narrow/wide)

Spark 的依赖只有两类,但这条区分线是整本书里最关键的一条:它同时决定了能否流水线执行、是否需要 shuffle、丢失分区要重算多大范围。理解窄依赖与宽依赖,就理解了 Stage 划分(第 3 章)与 Shuffle 引擎(第 4 章)的源头。

两种依赖的定义

看「子分区依赖几个父分区」:

类型定义例子
窄依赖每个子分区只依赖固定数量的父分区(通常 1 个)map / filter / union / 协同分区 join
宽依赖每个子分区依赖多个父分区,且父分区可能被多个子分区共享groupByKey / reduceByKey / 非协同 join / repartition

严格地说,窄依赖是「父分区到子分区的映射是确定的、一对少数的」;宽依赖是「需要按 key 重新分布数据,一个子分区可能收到来自所有父分区的数据」。判断标准不是算子名字,而是「数据是否需要跨分区移动」。

常见算子的依赖分类

窄依赖宽依赖
map、filter、flatMapgroupByKey
union(多父、一对一)reduceByKey
mapPartitionsjoin(两侧未协同分区)
sample、distinct 的第一阶段intersection、subtract
已协同分区的 joinrepartition、sortByKey

union 容易被误认为宽依赖,其实它是窄依赖:第 i 个子分区只来自某个父 RDD 的第 i 个分区,不需要重分布。distinct 则常是两阶段:先 map 成 (key, null),再 reduceByKey 去重——前半窄、后半宽。

窄依赖:可以流水线

窄依赖最重要的性质是可以流水线执行:父分区的数据流入子分区,不需要等整个父 Stage 完成。

map → filter → map 连成一条流水线:
  读一条记录 → 变换 1 → 变换 2 → 变换 3 → 写出
  每个分区独立跑,互不等待

lab 的 RddCore.canPipeline(Dep.NARROW) 返回 true、canPipeline(Dep.WIDE) 返回 false(用例 7-8)——这是「窄依赖可流水线、宽依赖是边界」的最小判据。流水线的价值在于中间结果不落盘:三个窄变换合并成一次遍历,少了两份中间 RDD 的物化。

宽依赖:Stage 边界

宽依赖必须等父 Stage 的全部任务完成,因为子 Stage 的每个任务可能要读所有父分区的数据:

Stage0(map/filter)全部完成
   ↓ shuffle write 落盘
Stage1(reduceByKey)才能开始
   ↓ shuffle read 拉取

这就是「宽依赖是 Stage 边界」的含义。lab 的 DagPlanner.countStages 验证:3 窄 + 1 宽 → 2 个 Stage(用例 1);2 个宽依赖 → 3 个 Stage(用例 3)。在这个线性教学模型中,Stage 数为宽依赖数加一,这个公式就是第 3 章 DAG 调度的起点。

DagPlanner.pipelineLength 则衡量「一段流水线有多长」:连续窄依赖段越长,合并的变换越多(用例 8)。宽依赖像一堵墙,把流水线截断——墙的一侧是父 Stage,另一侧是子 Stage。

依赖类型对容错的影响

依赖类型还决定了「丢失一个分区要重算多少」:

依赖丢失一个子分区重算范围
窄依赖只需重算对应的 1 个父分区小
宽依赖可能要重算所有父分区大

原因很直接:窄依赖里子分区与父分区是确定的映射,重算一个子分区只需要一条父链;宽依赖里子分区依赖所有父分区的数据,重算它可能要把整个父 Stage 的 shuffle 数据重新生成。窄依赖不仅快,恢复也便宜;宽依赖不仅慢,恢复更贵。这是 Spark 尽量把计算放在窄依赖里的深层原因。

宽依赖的两种优化:协同分区与广播

宽依赖虽然贵,但有两个常见的消除手段:

手段做法消除的 shuffle
协同分区(co-partitioning)两表用同一分区器、同一分区数分区join 的两侧 shuffle
广播(broadcast)小表广播到每个 Executor,大表不动小表侧的 shuffle

协同分区的前提是「两表都按 join key 分区」,常见于同一份数据被反复 join 的场景;广播的前提是「一侧足够小」,把几 MB 的表发给所有 Executor,让 join 退化成 map 侧查找。两者都是把宽依赖改写成窄依赖——第 9 章会展开 join 策略的选择。

这两个优化说明了一个重要判断:宽依赖的代价不是「必然」的,很多宽依赖可以被改写。调优时先问「这个 shuffle 能不能消掉」,再问「消不掉怎么优化」,顺序反了就会白做很多参数调整。

依赖链上的容错传播

依赖关系还决定了故障如何在链上传播:

rdd0 → map → rdd1 → filter → rdd2 → reduceByKey → rdd3

若 rdd3 的分区丢失,因为 reduceByKey 是宽依赖,重算可能要把 rdd2 的多个分区重新生成;而这些分区又依赖 rdd1、rdd0。反之,若 rdd1 的某个分区丢失(窄依赖),只需重算 rdd0 的对应分片。

越靠近宽依赖的下游,单点丢失的恢复成本越高——这就是为什么长作业要在宽依赖之后设检查点:宽依赖之后的 RDD 重算成本最高,截断血缘的收益也最大。

为什么 shuffle 是性能分水岭

把所有成本摊开看,宽依赖为什么贵:

成本项窄依赖宽依赖
数据移动无(本地)网络传输 + 磁盘落盘
序列化无(对象直接传递)必须序列化
等待分区级流水线全 Stage 屏障
文件数0map × reduce 个 shuffle 文件
失败代价重算一个分区可能重算整个 Stage

第一项与第四项是数量级的差别。这也解释了 Spark 优化的核心思路:能避免 shuffle 就避免(broadcast join、协同分区),不能避免就优化 shuffle(分区数、序列化、压缩、Shuffle 服务)。

Stage 划分的完整规则

把依赖与 Stage 串起来,划分规则其实只有一句话:

从最后一个 RDD 往前回溯:
  遇到窄依赖 → 并入当前 Stage
  遇到宽依赖 → 在此切开,父 RDD 起新 Stage

用 DagPlanner.stageOf 复现:[窄, 窄, 宽, 窄] 的阶段号是 [0, 0, 0, 1](用例 4)——宽依赖本身属于父 Stage,它之后的窄操作属于新 Stage。groups 把操作按阶段分组,得到「第 0 阶段 3 个操作、第 1 阶段 1 个操作」(用例 5-7)。

真实引擎的划分更细(要考虑 shuffle 依赖、ResultStage 与 ShuffleMapStage 的区分),但骨架就是这个回溯过程。看懂依赖,就看懂了 Stage 划分。

依赖与数据本地性

依赖类型还间接影响本地性:窄依赖的任务可以在「父分区所在的节点」执行(数据不动),宽依赖的 reduce 任务往往要跨网络拉数据(数据要动)。所以:

依赖任务优先位置
窄依赖父分区的所在节点(本地)
宽依赖shuffle 数据所在节点(尽量本地)

「移动计算而非移动数据」在窄依赖里天然成立,在宽依赖里只能尽量靠近。这也呼应了卷一 2.2 的数据本地性:宽依赖是本地性最容易被破坏的地方。

一条记忆线索

如果只记一句话,记这个:「宽依赖 = 要动数据」。map 是「一条记录进、一条记录出」,数据不动;groupByKey 是「同一个 key 从各处汇到一处」,数据必须动。凡是「按 key 汇聚」的操作,几乎都是宽依赖;凡是「逐条变换」的操作,几乎都是窄依赖。这个直觉不能覆盖所有边缘情况(比如协同分区 join),但足以判断绝大多数算子。

判断一个陌生算子时,问自己两个问题:它要不要按 key 重分布?它的每个输出分区会不会读到多个输入分区? 任一为「是」,就是宽依赖。

还有一个反向检验:如果这个算子的输出分区数 ≥ 输入分区数,且每个输出分区只来自一个输入分区,那它一定是窄依赖。map、filter、flatMap 都满足;repartition 不满足(它要重分布),所以是宽依赖。

三个常见误解

误解一:union 是宽依赖。 真相:union 是窄依赖,第 i 个子分区只对应某个父 RDD 的第 i 个分区,不需要重分布。

误解二:宽依赖只是「慢一点」。 真相:宽依赖是数量级的差别——网络传输、全 Stage 屏障、文件数增长、恢复范围扩大,每一项都可能成为瓶颈。

误解三:依赖类型由算子决定,与数据无关。 真相:同样是 join,两侧已用同一分区器分区时是窄依赖,否则是宽依赖。依赖类型取决于「数据是否需要跨分区移动」,不是算子名。

一句话总结本节

窄依赖是子分区只依赖固定父分区(map/filter/union/协同 join),宽依赖是需要按 key 跨分区重分布(groupByKey/reduceByKey/非协同 join/repartition);窄依赖可流水线、不落盘、重算便宜,宽依赖是 Stage 边界、必须 shuffle、恢复范围大——Stage 数 = 宽依赖数 + 1,整条划分规则就是「回溯血缘、遇宽即切」。

本节 lab

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

在 bd-spark-lab/ 中复现依赖分类与 Stage 边界:

  • 源码:src/rdd/RddCore.java(dependency / canPipeline)、src/dag/DagPlanner.java(countStages / stageOf / groups / pipelineLength)与 RddSuite、DagSuite。
  • 运行:javac -d out $(find src -name '*.java') && java -cp out lab.RunAll。
  • 断言:RddSuite 用例 5-8 验证依赖类型与可流水线判定;DagSuite 用例 1-8 验证「Stage 数 = 宽依赖数 + 1」、操作阶段号、分组与流水线长度。
  • 整卷 runner 的预期汇总为 TOTAL: 109 passed, 0 failed。

对应本节判断链:看子分区依赖几个父分区 → 窄依赖可流水线、宽依赖是边界 → Stage 按宽依赖切分——lab 的依赖判定与 Stage 计数就是这条链的两端。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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