罗罗编程学习记录
本页内容 展开查看

09.10.4 数据倾斜与 Shuffle 调优

所属:全栈开发面试题库 / 09 高阶架构:高并发与分布式 / 09.10 大数据与流处理

覆盖范围

  • 数据倾斜识别与定位
  • 倾斜解决方案:加盐、广播、map 端预聚合
  • Shuffle 调优参数
  • Spark/Flink 倾斜处理对照
  • 倾斜常见场景与排查

高频题速览

编号 题目 难度 频率
09.10.4-001 数据倾斜怎么识别 进阶 ★★★★★
09.10.4-002 数据倾斜产生原因 进阶 ★★★★☆
09.10.4-003 加盐怎么解决倾斜 进阶 ★★★★☆
09.10.4-004 广播 join 解决什么问题 进阶 ★★★★☆
09.10.4-005 map 端预聚合 进阶 ★★★★☆
09.10.4-006 Shuffle 调优参数有哪些 进阶 ★★★★☆
09.10.4-007 Spark AQE 倾斜处理 进阶 ★★★☆☆
09.10.4-008 Flink 数据倾斜怎么处理 高级 ★★★★☆
09.10.4-009 热点 key 怎么处理 进阶 ★★★★☆
09.10.4-010 倾斜排查步骤 进阶 ★★★☆☆

09.10.4-001 数据倾斜怎么识别?

一句话结论

数据倾斜表现为:部分 Task 处理数据量远大于其他 Task,少数 Task 运行时间长、其他 Task 早已完成;通过 Spark UI 看每个 Task 的数据量和耗时分布,或 Flink Web UI 看每个 Subtask 的处理量,定位倾斜 key。

概念解释

  • 倾斜表现:少数 Task 慢,其他 Task 快。
  • 识别:Spark UI 看 Stage 中每个 Task 的 records read 和 duration。
  • 定位倾斜 key:按 key 聚合,看哪个 key 数据量最大。

原理流程

Stage 执行:
  100 个 Task
  95 个 Task 处理 1 万条,10 秒完成
  5 个 Task 处理 100 万条,运行 1 小时
  → 倾斜

代码或图示

Spark UI 识别:
  Stage → 看每个 Task 的 Input Size / Records
  → 少数 Task 远大于其他

常见误区

  • 误区:所有 Task 都慢就是倾斜。所有 Task 都慢是资源不足,少数 Task 慢才是倾斜。
  • 误区:倾斜就是数据量大。数据量大但分布均匀不是倾斜,分布不均才是。

追问

  • 问:怎么定位倾斜 key?答:按 key 分组 count,topN key 数据量远超其他就是倾斜 key。
  • 问:Flink 怎么识别?答:Flink Web UI 看每个 Subtask 的 Records Received,不均就是倾斜。

09.10.4-002 数据倾斜产生原因是什么?

一句话结论

数据倾斜原因:按某个 key 分组时,少数 key 数据量远大于其他 key(例如空值、热点商品、大 V 用户);join 时某张表 key 分布不均,导致 join 后某些分区数据量暴增;本质是 key 分布不均 + Shuffle 按 key 分发。

概念解释

  • 热点 key:少数 key 数据量远大于其他。
  • Shuffle:按 key 分发,key 数据量决定分区数据量。
  • join 倾斜:一张表 key 集中,join 后放大。

原理流程

groupByKey(user_id):
  user_id = 空值 有 1000 万条
  其他 user_id 平均 100 条
  → 空值所在分区倾斜

代码或图示

常见倾斜 key:
  - 空值(NULL)
  - 默认值("unknown")
  - 热点商品 ID
  - 大 V 用户 ID

常见误区

  • 误区:数据倾斜是资源不够。资源不够是所有 Task 慢,倾斜是少数 Task 慢。
  • 误区:加并行度就解决倾斜。加并行度只是让更多 Task 处理倾斜 key,单个 key 仍在一个 Task。

追问

  • 问:空值为什么倾斜?答:空值被分到同一个分区,所有空值数据集中在一个 Task。
  • 问:join 倾斜怎么产生?答:A 表 key 集中,join B 表后,A 的集中 key 对应 B 的大量记录,导致分区数据量暴增。

09.10.4-003 加盐怎么解决倾斜?

一句话结论

加盐是给倾斜 key 加随机前缀,把一个 key 拆成多个 key,分散到多个分区处理;处理完后再去掉前缀聚合;适合 groupBy 聚合场景,不适合需要精确 join 的场景(join 时两张表都要加盐)。

概念解释

  • 加盐:key = key + "_" + random(0, N),把一个 key 拆成 N 个。
  • 两阶段聚合:先加盐聚合,再去掉前缀二次聚合。
  • 适用:groupBy/reduceByKey,不适合 join。

原理流程

倾斜 key = "hot"
  加盐:"hot_0", "hot_1", ..., "hot_N"
  → 分散到 N 个分区
  → 局部聚合
  → 去掉前缀,二次聚合

代码或图示

# 加盐两阶段聚合
rdd.map(lambda x: (x[0] + "_" + str(random.randint(0, 10)), x[1]))
   .reduceByKey(add)  # 局部聚合
   .map(lambda x: (x[0].split("_")[0], x[1]))
   .reduceByKey(add)  # 全局聚合

常见误区

  • 误区:加盐越多越好。加盐数 N 太大,局部聚合结果多,二次聚合开销大;N 按倾斜程度选。
  • 误区:加盐适合 join。join 时两张表都要加盐,且要保证相同随机前缀,实现复杂。

追问

  • 问:加盐数怎么定?答:按倾斜 key 数据量,例如倾斜 key 有 100 万条,加 10 个盐,每个 10 万条。
  • 问:join 场景怎么加盐?答:倾斜表加盐,另一张表膨胀(每个 key 复制 N 份),详见 09.10.4-004。

09.10.4-004 广播 join 解决什么问题?

一句话结论

广播 join 把小表广播到所有节点,大表不 Shuffle,直接在 map 端 join;适合一张表很小(几百 MB)、另一张大的场景;避免大表 Shuffle,解决 join 倾斜。

概念解释

  • 广播 join:小表广播到所有 Executor,大表本地 join。
  • 适用:一张表小(< 几百 MB),另一张大。
  • 避免 Shuffle:大表不 Shuffle,没有倾斜。

原理流程

小表(用户维表)→ 广播到所有节点
大表(订单事实表)→ map 端 join
  → 没有 Shuffle,没有倾斜

代码或图示

# Spark 广播 join
from pyspark.sql.functions import broadcast
orders.join(broadcast(users), "user_id")

常见误区

  • 误区:广播 join 适合所有 join。大表 join 大表不能广播,内存放不下。
  • 误区:广播 join 没有代价。小表广播占 Executor 内存,每个节点都存一份。

追问

  • 问:小表多大能广播?答:默认 10MB,可调 spark.sql.autoBroadcastJoinThreshold。
  • 问:两张表都大怎么办?答:倾斜 key 单独处理,非倾斜 key 正常 join。

09.10.4-005 map 端预聚合是什么?

一句话结论

map 端预聚合在 Shuffle 前先在 map 端局部聚合,减少 Shuffle 数据量;Spark 的 reduceByKey 自带 map 端 combine,groupByKey 没有;Flink 的 Combiner 类似;预聚合能减少 Shuffle 量和倾斜。

概念解释

  • map 端 combine:Shuffle 前局部聚合。
  • reduceByKey:map 端预聚合 + Shuffle + 全局聚合。
  • groupByKey:直接 Shuffle,没有预聚合。

原理流程

reduceByKey:
  map 端:局部合并 (k, v1), (k, v2) → (k, v1+v2)
  Shuffle:传输聚合后的结果
  下游:全局聚合
groupByKey:
  Shuffle:传输所有原始记录
  下游:全部聚合

代码或图示

对比:
  reduceByKey:Shuffle 数据量小(预聚合后)
  groupByKey:Shuffle 数据量大(原始记录)

常见误区

  • 误区:reduceByKey 完全没有 Shuffle。它仍有 Shuffle,只是 Shuffle 前预聚合了。
  • 误区:groupByKey 一定慢。简单聚合 groupByKey 也能用,但数据量大时 reduceByKey 更好。

追问

  • 问:什么时候用 reduceByKey?答:需要聚合(sum/count)时,预聚合减少 Shuffle。
  • 问:什么时候必须用 groupByKey?答:聚合函数不满足结合律(如求平均值),不能预聚合。

09.10.4-006 Shuffle 调优参数有哪些?

一句话结论

Spark Shuffle 调优参数:spark.sql.shuffle.partitions(Shuffle 分区数)、spark.shuffle.compress(压缩)、spark.shuffle.spill(溢写)、spark.reducer.maxSizeInFlight(拉取大小);Flink 调优:buffer 数量、Network Memory。

概念解释

  • 分区数:Shuffle 后分区数,太少倾斜,太多小文件。
  • 压缩:Shuffle 数据压缩,减少磁盘和网络。
  • 溢写:内存不够时溢写磁盘。

原理流程

分区数:
  太少 → 单个分区数据量大 → 倾斜
  太多 → 小文件多 → 调度开销大
  默认 200,按数据量调

代码或图示

Spark 参数:
  spark.sql.shuffle.partitions = 500
  spark.shuffle.compress = true
  spark.reducer.maxSizeInFlight = 48m

常见误区

  • 误区:分区数越多越好。太多小文件,调度开销大。
  • 误区:分区数固定。按数据量调,大作业分区数多。

追问

  • 问:分区数怎么定?答:每个分区 128MB 左右,按总数据量算。
  • 问:AQE 动态调整?答:Spark 3.x AQE 自动合并小分区、拆分倾斜分区,详见 09.10.4-007。

09.10.4-007 Spark AQE 倾斜处理是什么?

一句话结论

AQE(Adaptive Query Execution)是 Spark 3.x 的自适应执行:运行时根据 Shuffle 统计信息动态调整,包括自动合并小分区、自动拆分倾斜分区、动态切换 join 策略;不需要手动加盐,AQE 自动处理倾斜。

概念解释

  • 合并小分区:AQE 把小分区合并成大分区。
  • 拆分倾斜分区:AQE 发现某分区数据量远超其他,自动拆分成多个子分区。
  • 动态 join:运行时发现小表,自动切换 Broadcast Join。

原理流程

AQE 开启:
  spark.sql.adaptive.enabled = true
  spark.sql.adaptive.skewJoin.enabled = true
  → 运行时自动识别倾斜,拆分区

代码或图示

AQE 倾斜处理:
  倾斜分区(数据量 100 万)→ 拆成 10 个子分区(每个 10 万)
  → 并行处理

常见误区

  • 误区:AQE 完全解决倾斜。AQE 处理常见倾斜,复杂场景仍需手动优化。
  • 误区:AQE 自动开启。需要显式配置 spark.sql.adaptive.enabled。

追问

  • 问:AQE 什么时候触发?答:Shuffle 后根据统计信息调整,下一个 Stage 生效。
  • 问:AQE 代价?答:运行时收集统计信息,有少量开销,但收益大于开销。

一句话结论

Flink 数据倾斜处理:keyBy 后少数 key 数据量大,导致某个 Subtask 负载高;解决方案有:两阶段聚合(类似加盐)、局部聚合 + 全局聚合、KeyGroup 重新分配、热点 key 单独处理;Flink 没有 AQE,需要手动设计。

概念解释

  • Subtask 倾斜:某个并行子任务处理数据量远超其他。
  • 两阶段聚合:局部聚合(key 带随机前缀)→ 全局聚合(去前缀)。
  • 热点 key:单独处理,拆分或预聚合。

原理流程

Flink 倾斜:
  keyBy(user_id) → Subtask 3 处理热点用户
  → Subtask 3 负载高,反压
两阶段聚合:
  map 端加随机前缀 → 局部聚合 → 去前缀 → 全局聚合

代码或图示

// Flink 两阶段聚合
stream.keyBy(keyWithRandomPrefix)
      .process(localAgg)  // 局部聚合
      .keyBy(originalKey)
      .process(globalAgg) // 全局聚合

常见误区

  • 误区:Flink 增加并行度就解决倾斜。增加并行度只是更多 Subtask,热点 key 仍在一个 Subtask。
  • 误区:Flink 有 AQE。Flink 没有 Spark AQE,倾斜要手动设计。

追问

  • 问:Flink 广播状态?答:小维表广播,避免 Shuffle,类似 Spark Broadcast Join。
  • 问:Flink 热点 key 怎么处理?答:两阶段聚合或预聚合,把热点 key 分散。

09.10.4-009 热点 key 怎么处理?

一句话结论

热点 key 是少数 key 访问量远高于其他,导致单节点压力大;处理方式:本地缓存(Caffeine)、key 拆分(加盐分散)、多副本读、热点探测;本质是把单节点压力分散到多节点。

概念解释

  • 热点 key:少数 key 数据量或访问量远高于其他。
  • 本地缓存:热点数据在每个节点本地缓存,减少跨节点访问。
  • key 拆分:加盐把一个 key 拆成多个,分散到多节点。

原理流程

热点 key "product_123":
  1. 本地缓存:每个节点缓存 product_123,不访问 Redis
  2. key 拆分:product_123_0, product_123_1, ...
     → 分散到多个 Redis 节点

代码或图示

热点 key 处理:
  - 本地缓存(Caffeine)
  - 加盐拆分
  - 多副本
  - 热点探测(监控 key 访问频率)

常见误区

  • 误区:热点 key 加 Redis 集群就解决。Redis Cluster 按 key 哈希,热点 key 仍在一个节点。
  • 误区:本地缓存一定一致。本地缓存有 TTL,热点数据可能短暂不一致,按业务容忍。

追问

  • 问:热点 key 怎么探测?答:Redis 监控 hotkeys、代理层统计 key 访问频率。
  • 问:和缓存倾斜什么关系?答:缓存倾斜是热点 key 导致单节点压力大,详见 09.3.2.4。

09.10.4-010 倾斜排查步骤是什么?

一句话结论

排查步骤:1. 看 UI 确认少数 Task 慢;2. 按 key 聚合定位倾斜 key;3. 判断是 groupBy 倾斜还是 join 倾斜;4. 选方案(加盐/广播/预聚合);5. 验证效果;6. 监控持续观察。

概念解释

  • UI 确认:少数 Task 慢。
  • 定位倾斜 key:按 key count,topN 数据量远超其他。
  • 选方案:按场景选加盐/广播/预聚合。

原理流程

1. Spark UI / Flink UI 看 Task 分布
2. 按 key 聚合 count,找倾斜 key
3. 判断倾斜类型:groupBy 还是 join
4. 选方案:
   groupBy → 加盐两阶段聚合
   join → 广播小表 or 加盐
5. 上线验证,看 Task 分布是否均匀

代码或图示

排查清单:
  [ ] 少数 Task 慢?
  [ ] 哪个 key 倾斜?
  [ ] groupBy 还是 join 倾斜?
  [ ] 方案:加盐/广播/预聚合?
  [ ] 上线后 Task 分布均匀?

常见误区

  • 误区:一上来就加资源。先定位倾斜 key,再选方案,盲目加资源浪费。
  • 误区:倾斜解决一次就不管了。数据分布变化,要持续监控。

追问

  • 问:怎么持续监控?答:每天跑 key 分布统计,倾斜率告警。
  • 问:join 倾斜怎么定位?答:分别统计两张表 key 分布,看哪张表 key 集中。

待整理清单

  • [ ] Spark 倾斜处理代码示例
  • [ ] Flink 两阶段聚合实现
  • [ ] 倾斜监控与告警方案