Spark 宽依赖和窄依赖

宽依赖为什么切 Stage?

章节

  • 0:00 开场
  • 0:23 一句话回答
  • 0:49 窄依赖 · 一对一
  • 1:23 宽依赖 · 一对多
  • 2:00 区别 ① · Stage 划分
  • 2:35 区别 ② · 执行方式
  • 3:12 区别 ③ · 容错代价
  • 3:38 加分点 ① · join 一定是宽依赖?
  • 4:02 加分点 ② · reduceByKey
  • 4:29 加分点 ③ · Spark UI
  • 4:44 高频追问
  • 5:16 面试回答模板

文稿

开场

面试官问你:Spark 的宽依赖和窄依赖,有什么区别?你脱口而出:窄依赖一对一,宽依赖一对多。面试官点点头,接着追问:那为什么,宽依赖是 Stage 的分界线?大部分人就卡在这里。今天用动画,把这道 Spark 出场率最高的基础题讲透。

一句话回答

先给一句话答案。窄依赖:父 RDD 的一个分区,只流向子 RDD 的一个分区。它可以在同一个 Task 里流水线执行,不落盘。宽依赖:父 RDD 的一个分区,流向子 RDD 的多个分区,必须经过 Shuffle 落盘,它就是 Stage 的分界线。区分它们的目的只有一个:把尽可能多的操作合并进一个 Stage,减少 Shuffle。

窄依赖 · 一对一

先看窄依赖。父 RDD 的每个分区,最多只被子 RDD 的一个分区依赖。数据不用跨节点传输,在同一台机器、同一个 Task 里就能算完。它就像工厂流水线上的传送带:零件从 A 工位直线传到 B 工位,不会拆到别的工位去。常见的有 map、filter、flatMap、mapPartitions,还有 union 和 coalesce。union 有两个父 RDD,看起来是多对一,但每个父分区仍然只流向一个子分区,所以还是窄依赖。

宽依赖 · 一对多

再看宽依赖。父 RDD 的一个分区,被子 RDD 的多个分区依赖。比如父分区 0 里有 a、b、c 三种 key,Shuffle 之后,a 去子分区 0,b 去分区 1,c 去分区 2。一个分区被拆散了。这意味着三件事:要走网络,要落磁盘,而且不可能在一个 Task 里完成,必须拆成两个 Stage。它就像快递分拣中心:所有包裹都得扫描一遍,按地址分到不同的车上。常见的有 groupByKey、reduceByKey、普通 join、distinct、repartition 和 sortByKey。

区别 ① · Stage 划分

那为什么要区分?第一个,也是最核心的原因:Stage 划分。Spark 切分 Stage 的规则很简单:从后往前回溯 DAG,遇到宽依赖,就切一刀。看这段代码:filter、map 都是窄依赖,不切;到了 reduceByKey,宽依赖,切!后面的 filter、map、save 又是窄依赖,归到 Stage 2。两个 Stage 之间,靠 Shuffle 连接。所以窄依赖越多,Stage 越长,执行越高效;宽依赖越多,Stage 切得越碎,性能越差。

区别 ② · 执行方式

第二个区别:执行方式。窄依赖的连续算子在同一个 Task 里流水线执行:取一条数据,filter,map,输出,再取下一条,全程在内存里流转。宽依赖必须落盘,分两步。第一步 Shuffle Write:每个 Map Task 按 key 分桶,写到本地磁盘。第二步 Shuffle Read:每个 Reduce Task,再从所有节点拉取属于自己的那一份。这也是 Spark 比 MapReduce 快的原因:MapReduce 每一步都落盘,Spark 只在不得不 Shuffle 的地方才落盘。

区别 ③ · 容错代价

第三个区别:容错代价。假设一个 Executor 挂了,某个子分区的数据丢了。如果是窄依赖,它只依赖一个父分区,只重算这一个,代价很小。如果是宽依赖,它依赖所有父分区的一部分数据,整个父 Stage 都要重算一遍。所以在迭代计算里,建议在宽依赖之后 persist 或 cache,把 Shuffle 的结果缓存起来。

加分点 ① · join 一定是宽依赖?

接下来是几个加分点。第一:join 一定是宽依赖吗?不一定。普通的 join,两边都要按 join key 重新 Shuffle,是宽依赖。但如果两边已经用相同的分区器、相同的分区数,按同一个 key 分好了区,分区 0 直接和分区 0 在本地 join,不用 Shuffle,这就是窄依赖。能主动说出这一点,说明你理解了本质。

加分点 ② · reduceByKey

第二:同样是宽依赖,reduceByKey 比 groupByKey 快得多。groupByKey 会把一百万条记录,原封不动地 Shuffle 到 Reduce 端,再去求和。reduceByKey 会先在 Map 端预聚合,一百万条变成一条,Shuffle 的数据量几乎降到零。所以被问到怎么优化 Shuffle,第一条就是:能用 reduceByKey,就别用 groupByKey。

加分点 ③ · Spark UI

第三:在 Spark UI 上,每个 Stage 的边界就是一次 Shuffle,Stage 里的 Task 数,就是它处理的分区数。点开 Stage,还能看到 Shuffle Read 和 Shuffle Write 的数据量,这是性能调优的关键指标。

高频追问

再来看三个高频追问。一:coalesce 和 repartition 都能改分区数,为什么一窄一宽?coalesce 只能减少分区,把几个父分区合并成一个,是窄依赖;repartition 底层强制 Shuffle,重新打散,是宽依赖。二:窄依赖也会慢吗?会。源头分区不均匀,倾斜会沿着窄依赖一路传下去,可以先 repartition 打散。三:自定义算子怎么判断宽窄?只看一点:计算时,需不需要其他分区的数据。

面试回答模板

最后,面试回答模板来了。窄依赖一对一,不 Shuffle,流水线执行;宽依赖一对多,必须 Shuffle,是 Stage 的分界线。区分它有三个意义:划分 Stage,决定执行效率,决定容错代价。优化方向就是减少宽依赖:reduceByKey 预聚合,小表广播,提前 partitionBy,宽依赖之后做缓存。记住一句话:宽依赖切 Stage,窄依赖跑流水线。

看完去做题