Skip to content

03 · Spark 调优:Shuffle、数据倾斜与小文件 ​

学完你能说出:

  • reduceByKey 为什么比 groupByKey 快,求平均值时传什么。
  • 数据倾斜的现象、怎么确认,以及 3 种常用解法:过滤脏 key、加盐两阶段聚合、广播 join。
  • repartition 和 coalesce 的区别,小文件问题怎么来、怎么治。

先看地图 ​

上一篇说过,Shuffle(跨机器重新分组)是 Spark 里最慢的一步。所以调优的核心就一句话:少 Shuffle,Shuffle 时少传数据,让每个 Task 干的活差不多。本篇讲 4 个点:

① reduceByKey vs groupByKey → ② 数据倾斜 → ③ repartition vs coalesce → ④ 小文件问题

一句话本质 ​

调优就是对付 Shuffle:能在本地先汇总的先汇总(少传),数据分布不均时把大块拆开(防倾斜),输出时把分区数控制好(防小文件)。

生活类比 ​

全班 50 人统计每个省的同学人数:

  • groupByKey:每个人都把自己的名条交给负责那个省的同学,「广东」同学收到 30 张名条再数。
  • reduceByKey:每个小组先数好「我们组广东 3 人」,只交一张汇总条。
  • 数据倾斜:一半同学都是广东的,负责广东的那位数到最后,其他人早就数完在等他。
  • 加盐:把广东拆给 5 个人分别数,最后再把 5 个数加起来。

一步步看 ​

1. reduceByKey vs groupByKey ​

统计每个城市的订单数,1000 万条订单分布在 100 个分区,共 300 个城市:

groupByKeyreduceByKey
Shuffle 前不做处理每个分区先在本地按城市求和(预聚合)
要传多少条1000 万条 (城市, 1)最多 100 × 300 = 3 万条(城市, 本分区小计)
风险一个城市的所有值都要装进一个 Task 的内存,容易 OOM很小

求平均值怎么办:平均值不能先算局部平均再平均(两个分区 2 条均值 10、8 条均值 20,直接平均得 15,真实是 18)。要传 (总和, 个数):

scala
orders.map(o => (o.city, (o.amount, 1)))
      .reduceByKey { case ((s1, c1), (s2, c2)) => (s1 + s2, c1 + c2) }   // 各分区先加总和、个数
      .mapValues { case (sum, cnt) => sum / cnt }                         // 最后再除

2. 数据倾斜:一个 Task 卡在 99% ​

← 左右滑动看完整图 →原始 key北京 900 万行上海 10 万行① 加盐北京 → 0_北京 … 9_北京每个约 90 万行② 局部聚合10 个 Task各自求和③ 去盐再聚合0_北京…9_北京→ 北京不加盐:Task 1(北京)Task 2(上海)Task 3(广州)加盐后:北京拆成 10 份,每份约 90 万行,最慢的 Task 快约 10 倍;代价是多一次聚合只适用于求和、计数这类能分两步算的聚合;join 倾斜常用「广播小表」或「拆出热点 key 单独处理」
数据倾斜时的「加盐两阶段聚合」:北京有 900 万行,其他城市各约 10 万行。第一阶段给 key 加上 0–9 的随机前缀,北京被拆到 10 个 Task 里各算约 90 万行;第二阶段去掉前缀再合并一次。最慢的 Task 从 900 万行降到约 90 万行。

现象:Spark UI 里一个 Stage 的 200 个 Task,199 个几秒就完成了,剩 1 个跑了 40 分钟;或者那一个 Task 内存溢出失败。

原因:Shuffle 按 key 分组,某个 key 的数据特别多,全部落到同一个 Task。常见的有:

  • 空值、默认值:user_id 为 NULL 或 0 的日志有几千万行;
  • 真实热点:北京的订单是其他城市的几十倍;
  • 大表 join 时某个 key 在两边都很多。

怎么确认:看 Spark UI 里各 Task 的处理行数和耗时;或者先对 key 做一次计数,看前几名是不是远超平均值。

3 种常用解法:

解法适用场景做法代价
过滤或单独处理脏 key倾斜来自 NULL、0、测试数据先过滤掉;如果业务上需要,就把它们单独算再合并要确认这些数据真的可以去掉
加盐两阶段聚合求和、计数这类聚合时某些 key 太大① 给 key 加 0–9 的随机前缀 ② 按加盐的 key 局部聚合 ③ 去掉前缀再聚合一次多一次 Shuffle;只适用于能分两步算的聚合
广播 join大表 join 小表(小表几十 MB 以内)把小表复制到每个 Executor 的内存里,大表在本地直接匹配,完全不 Shuffle小表必须放得进内存

广播 join 的例子:1 亿行订单表 join 300 行的城市维度表。普通 join 要按城市 Shuffle 两张表,北京又会倾斜;广播之后每个 Task 拿着一份完整的城市表,在本地完成匹配。Spark SQL 对小于 spark.sql.autoBroadcastJoinThreshold(默认 10 MB)的表会自动广播。

另外,Spark 3 的 AQE(Adaptive Query Execution,自适应查询执行) 能在运行中发现倾斜的分区并自动拆分,可以先打开它再看效果。

3. repartition vs coalesce ​

repartition(n)coalesce(n)
会不会 Shuffle会,数据完全重新打散不会(默认),只是把几个分区合并成一个
能增能减能增能减只能减
数据是否均匀均匀可能不均匀
典型用途分区太少要提高并行度;数据倾斜后重新打散过滤后数据变少,输出前减少文件数

例子:1000 个分区的数据过滤后只剩 1%,直接写出会生成 1000 个很小的文件;先 coalesce(10) 再写,只有 10 个文件。

4. 小文件问题 ​

怎么来的:Spark 每个分区写一个文件。Spark SQL 的 Shuffle 默认 200 个分区(spark.sql.shuffle.partitions = 200),每天按小时分区写一次,一天就是 24 × 200 = 4800 个文件,即使每个只有几 KB。

有什么危害:NameNode 元数据暴涨(见 Hadoop);下游读的时候每个文件一个 Task,启动开销比计算还大。

怎么治:

  • 写出前 coalesce 到合适的分区数(每个文件 128 MB 左右);
  • 根据数据量调小 spark.sql.shuffle.partitions,或者打开 AQE 自动合并小分区;
  • Hive 表可以开启合并小文件的参数,或定期跑一个合并任务。

为什么这么设计 ​

为什么 reduceByKey 比 groupByKey 快? ​

  • 问题:groupByKey 把所有值原样通过网络传给下游,数据量大、还容易让一个 Task 内存溢出。
  • 方案:reduceByKey 在 Shuffle 前先在每个分区本地按 key 合并(类似 MapReduce 的 Combiner)。
  • 好处:传输量从「总行数」降到「分区数 × key 数」,内存压力也小。

一句话答法

reduceByKey 在 Shuffle 前先在本地按 key 预聚合,只传每个分区的小计;groupByKey 把所有值原样传过去,网络开销大还容易 OOM。求平均要传(总和, 个数)。

为什么加盐能解决聚合倾斜? ​

  • 问题:倾斜的根源是一个 key 的数据全部落进同一个 Task。
  • 方案:给 key 加随机前缀,把一个大 key 拆成 10 个小 key 分到 10 个 Task 先算局部结果,再去掉前缀合并。
  • 好处:最慢的 Task 处理量降到约十分之一;代价是多一轮 Shuffle(但第二轮的数据量已经很小)。

一句话答法

加盐把一个热点 key 打散成多个 key,先分到多个 Task 局部聚合,再去掉前缀二次聚合,最慢的 Task 工作量就降下来了。

为什么大表 join 小表要用广播? ​

  • 问题:普通 join 要把两张表都按 key Shuffle,大表 Shuffle 很贵,热点 key 还会倾斜。
  • 方案:把小表复制一份到每个 Executor,大表每个分区在本地就能完成匹配。
  • 好处:大表完全不用 Shuffle,也就不存在倾斜;代价是小表要能放进内存。

一句话答法

广播 join 把小表复制到每个 Executor,大表在本地直接匹配,省掉了大表的 Shuffle,也就避开了倾斜,前提是小表放得进内存。

英文术语拆解 ​

术语拆开看一句话意思
Data SkewData 数据 + Skew 歪斜数据倾斜:某些 key 的数据远多于其他
SaltingSalt 盐 + ing加盐:给 key 加随机前缀打散
Broadcast JoinBroadcast 广播 + Join 连接把小表发给所有节点的 join
RepartitionRe 重新 + partition 分区重新分区(会 Shuffle)
Coalesce合并、联合合并分区(默认不 Shuffle)
AQEAdaptive 自适应 + Query 查询 + Execution 执行运行时根据真实数据调整执行计划
CombinerCombine 合并 + r 者MapReduce 中 Map 端的本地预聚合

面试怎么问 ​

Q:reduceByKey 和 groupByKey 有什么区别?

reduceByKey 在 Shuffle 之前会在每个分区本地先按 key 预聚合,只把每个分区的小计传给下游;groupByKey 不预聚合,所有值原样通过网络传输,数据量大,而且一个 key 的所有值要放进一个 Task 的内存,容易 OOM。能用 reduceByKey、aggregateByKey 就不用 groupByKey。

Q:遇到过数据倾斜吗?怎么处理?

如果没在真实项目里遇到过,就照实说,然后讲知道的处理方法。现象是一个 Stage 里个别 Task 远比其他慢,甚至 OOM,可以在 Spark UI 看各 Task 的数据量确认,或者先统计 key 的分布。处理:倾斜来自空值或脏数据就过滤或单独处理;聚合倾斜用加盐两阶段聚合;大表 join 小表用广播 join 避免 Shuffle;Spark 3 可以先打开 AQE 自动处理倾斜分区。

Q:repartition 和 coalesce 的区别?

repartition 会 Shuffle,能增能减,数据重新均匀打散;coalesce 默认不 Shuffle,只能减少分区,把相邻分区合并,速度快但可能不均匀。输出前减少文件数用 coalesce,需要提高并行度或打散倾斜数据用 repartition。

Q:Spark 写出很多小文件怎么办?

原因是每个分区写一个文件,而 Shuffle 默认 200 个分区,数据量小的时候就产生大量小文件。办法是写出前 coalesce 到合适的分区数,让每个文件在 128 MB 左右;或者调小 spark.sql.shuffle.partitions、打开 AQE 自动合并分区;已经产生的小文件定期合并。

容易混的地方 ​

  • 数据倾斜 ≠ 数据量大:数据量大但分布均匀,加机器就行;倾斜是「一个 Task 特别重」,加机器没用。
  • 加盐不能直接用于求中位数、去重计数:这类不能简单分两步合并的计算要换方法。
  • coalesce(n, shuffle = true) 就等于 repartition(n)。
  • 广播的是小表,不是大表:把大表广播出去会把每个 Executor 撑爆。

和其他知识的连接 ​

  • ← 来自 Spark 原理:Shuffle 和 Stage 的概念。
  • ← 来自 Hadoop:小文件为什么伤害 NameNode。
  • → 影响 Hive 表:分区、分桶和小文件合并。
  • → 影响 数仓分层与建模:大表 join 维度表就是事实表 join 维度表。

自测 3 问 ​

Q1:两个分区里,A 分区 2 条订单均价 10 元,B 分区 8 条订单均价 20 元。直接对两个均值再求平均,得多少?正确答案是多少?Spark 里该怎么算?

点开看答案

直接平均得 15 元;正确的是 (2×10 + 8×20) / 10 = 18 元。Spark 里每个分区传(总和, 个数):A 是 (20, 2),B 是 (160, 8),用 reduceByKey 相加得 (180, 10),最后再除,得 18。

Q2:200 个 Task 中 199 个 5 秒完成,1 个跑了 40 分钟。可能是什么原因?怎么确认、怎么解决?

点开看答案

数据倾斜:某个 key 的数据特别多,落在同一个 Task 里。在 Spark UI 看这个 Task 处理的行数,或者对 key 计数看分布。如果是空值或脏 key 就过滤或单独处理;聚合类用加盐两阶段聚合;join 小表用广播 join;也可以开 AQE。

Q3:过滤后数据只剩原来的 1%,直接写出有什么问题?用 repartition 还是 coalesce?

点开看答案

分区数没变,会写出大量很小的文件,加重 NameNode 和下游读取的负担。用 coalesce 减少分区数,它默认不 Shuffle,比 repartition 快。

✅ 验收清单 ​

  • 能用数字说明 reduceByKey 比 groupByKey 少传多少数据
  • 能写出用(总和, 个数)求平均的思路
  • 能说出数据倾斜的现象、确认方法和 3 种解法,并画出加盐的 3 步
  • 能对比 repartition 和 coalesce 的 4 个区别
  • 能说出小文件的来源、危害和 2 种治理方法

下一步该懂什么 ​