彻底搞懂Spark数据倾斜：原理解析与性能优化

引言：Spark 任务的"隐形杀手"------数据倾斜

想象一下，您正在使用 Apache Spark 处理海量数据，一个关键的 Join 或 GroupBy 操作，本以为会很快完成，结果却发现任务卡在某个阶段迟迟不前，部分 Executor CPU 飙升、内存溢出（OOM），而其他 Executor 却闲置着，资源利用率低下。这种令人头疼的现象，正是我们今天要深入探讨的"数据倾斜"（Data Skew）。

数据倾斜是分布式计算中常见的"顽疾"，它像一个隐形杀手，悄无声息地吞噬着宝贵的计算资源，严重拖慢 Spark 任务的执行效率，甚至导致任务失败。对于大数据工程师而言，理解并掌握数据倾斜的处理策略，是提升 Spark 应用性能和稳定性的必备技能。今天，就让我们一起彻底搞懂数据倾斜，并学会如何用实战代码化解它！

让我们先来看一个可能导致数据倾斜的"问题代码"示例。假设我们有两个数据集 df_orders 和 df_users，需要根据 user_id 进行关联查询：

# problem_example.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit

spark = SparkSession.builder \
    .appName("DataSkewProblemDemo") \
    .getOrCreate()

# 模拟订单数据，其中user_id=1000的订单量异常巨大
orders_data = [    (1, 1000, 100.0), (2, 1000, 150.0), (3, 1000, 200.0), (4, 1000, 120.0), # 倾斜key    (5, 1001, 50.0), (6, 1002, 80.0), (7, 1003, 90.0), (8, 1004, 110.0)]
# 额外生成大量user_id=1000的订单，模拟倾斜
for i in range(9, 10000):
    orders_data.append((i, 1000, float(i % 200)))
for i in range(10000, 20000):
    orders_data.append((i, i, float(i % 100)))

# 模拟用户数据，user_id=1000的用户是存在的
users_data = [
    (1000, "Alice", "New York"), (1001, "Bob", "London"),
    (1002, "Charlie", "Paris"), (1003, "David", "Tokyo"),
    (1004, "Eve", "Sydney")
]
# 补充一些非倾斜的用户
for i in range(10005, 20000):
    users_data.append((i, f"User_{i}", f"City_{i % 10}"))

df_orders = spark.createDataFrame(orders_data, ["order_id", "user_id", "amount"])
df_users = spark.createDataFrame(users_data, ["user_id", "user_name", "city"])

print("原始订单数据样本：")
df_orders.show(5)
print("原始用户数据样本：")
df_users.show(5)

# 问题：直接进行Join操作，如果user_id=1000的数据量非常大，会发生倾斜
print("\
--- 尝试直接Join ---")
joined_df = df_orders.join(df_users, "user_id")
joined_df.show(5)
joined_df.explain(True) # 查看执行计划

# 统计user_id分布，可以清晰看到user_id=1000的倾斜情况
print("\
--- user_id 分布统计 --- ")
df_orders.groupBy("user_id").count().orderBy(col("count").desc()).show(5)

spark.stop()

当执行上述代码时，您会发现在 df_orders.groupBy("user_id").count() 的结果中，user_id=1000 的记录数远超其他 user_id。这意味着在后续的 Join 或 GroupBy 操作中，所有 user_id=1000 的数据都会被分发到同一个或少数几个 Task 上，导致这些 Task 成为性能瓶颈，这就是典型的"数据倾斜"！

第一章：深入理解数据倾斜：现象、危害与根源

什么是数据倾斜（Data Skew）？

在分布式计算领域，数据倾斜指的是在数据处理过程中，集群中的某些 Task 或节点处理的数据量远超其他 Task 或节点，导致这些"忙碌"的 Task 成为整个作业的瓶颈。想象一下，一个团队中，90% 的工作量都压在一个人身上，而其他成员无所事事，团队效率自然会非常低下。数据倾斜就是 Spark 任务中的这种"工作量分配不均"现象。

数据倾斜的危害

1. 任务性能瓶颈：整体任务的完成时间取决于最慢的 Task，数据倾斜会显著拉长 Task 的执行时间。
2. 资源利用率低下：少数 Task 满载，大部分 Task 闲置，集群资源得不到充分利用。
3. 内存溢出（OOM） ：当单个 Task 需要处理的数据量过大时，可能会超出其分配的内存，导致 OOM 错误，任务失败。
4. Shuffle 性能下降：倾斜的数据在 Shuffle 阶段可能会导致网络传输瓶颈。

数据倾斜的根源

理解倾斜的根源是解决问题的第一步。主要原因包括：

• Key 分布不均匀 ：这是最常见的原因，例如在 Join 或 GroupBy 操作中，某些 Key 的出现频率远高于其他 Key。如电商场景中，VIP 用户的订单量可能远大于普通用户，导致 user_id 在 Join 时出现倾斜。
• 数据源问题 ：原始数据中存在大量的 null 值、空字符串或默认值（如 -1、0），这些特殊值在作为 Join Key 或 GroupBy Key 时，会天然地聚集在一起，形成"热点 Key"。
• 业务逻辑问题：某些复杂的业务逻辑在数据处理时，无意中产生了热点 Key。
• SQL 操作不当 ：例如，使用 LEFT JOIN 时，如果左表中有大量重复的 Key，也会导致右表的数据被多次扫描，进而加剧倾斜。

第二章：数据倾斜的侦察兵：如何识别与定位

在 Spark 任务中，数据倾斜往往不是一开始就显现的，它可能隐藏在复杂的执行流程中。学会如何快速识别和定位倾斜点，是解决问题的前提。

1. Spark UI：您的第一侦察工具

Spark UI 是监控 Spark 任务最直观、最强大的工具。当任务发生数据倾斜时，Spark UI 通常会显示以下迹象：

• Stage 页面 ：观察所有 Stage 的耗时。如果某个 Stage 的耗时显著长于其他 Stage，并且该 Stage 涉及到 Shuffle 读写（如 Join, GroupBy, Aggregation），那么很可能发生了数据倾斜。
• Tasks 页面 ：点击进入某个可疑的 Stage，查看其 Tasks 列表。如果发现绝大部分 Task 完成得很快，但有少数 Task 的执行时间（Duration）、数据读取量（Input Size / Shuffle Read Size）、写入量（Shuffle Write Size）或 GC 时间（GC Time）远超其他 Task 的平均值，那么基本可以断定发生了数据倾斜。尤其关注 Shuffle Write Size 和 Shuffle Read Size 明显高于平均值的 Task。
• Executors 页面：检查每个 Executor 的 CPU 使用率和内存使用情况。倾斜的 Executor 可能会长时间处于高负载状态，甚至出现 OOM。

2. 日志分析

如果任务直接失败，可以检查 Driver 或 Executor 的日志。常见的与倾斜相关的错误信息包括：

• java.lang.OutOfMemoryError：内存溢出，这通常是倾斜 Task 试图处理过多数据导致的。
• WARN YarnAllocator: Container ... killed by YARN：容器被 YARN 杀死，可能也是内存或 CPU 资源耗尽所致。

3. 数据抽样与统计分析

通过对原始数据或中间结果进行抽样和统计，可以更精确地找到热点 Key。

代码示例：统计 Key 的分布

我们可以对可能引起倾斜的 Key 进行 groupBy().count() 操作，并按计数降序排列，以找出出现频率最高的 Key。

# identify_skew.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, rand

spark = SparkSession.builder \
    .appName("IdentifyDataSkew") \
    .getOrCreate()

# 模拟一个存在严重倾斜的DataFrame
def create_skewed_df(spark_session):
    # 制造一个热点key 'skew_val'
    data = []
    for i in range(100000):
        data.append((i, 'common_val_' + str(i % 100), i))
    for i in range(10000):
        data.append((i + 100000, 'skew_val', i))
    # 再加入一些其他的key
    for i in range(110000, 200000):
        data.append((i, 'common_val_' + str(i % 50), i))

    return spark_session.createDataFrame(data, ['id', 'key', 'value'])

df_skewed = create_skewed_df(spark)
print("--- 原始数据样本 ---")
df_skewed.show(5)

# 统计 'key' 列的分布情况，找出出现频率最高的key
print("\
--- 'key' 列分布统计（降序）---")
df_skewed.groupBy("key").count().orderBy(col("count").desc()).show(10, truncate=False)

# 如果需要更精确的Top N统计，可以收集到Driver进行分析（注意数据量）
# top_keys = df_skewed.groupBy("key").count().orderBy(col("count").desc()).limit(10).collect()
# for row in top_keys:
#     print(f"Key: {row['key']}, Count: {row['count']}")

spark.stop()

执行上述代码后，你会看到 skew_val 的计数远高于其他 common_val_xx，这明确指出了倾斜的 Key。有了这些侦察结果，我们就可以着手制定"反倾斜"策略了。

第三章：数据倾斜的"化解之道"：核心优化策略与代码实战

解决数据倾斜的本质是设法将热点 Key 的数据打散，使其在不同 Task 或节点上并行处理。下面介绍几种核心优化策略及其 PySpark 代码实现。

策略一：聚合操作倾斜处理------两阶段聚合（局部聚合 + 全局聚合）

当 groupBy() 或 agg() 操作出现倾斜时，通常是因为某个 Key 的数据量过大，导致所有这些数据都发送到一个 Task 进行聚合。两阶段聚合（或称"预聚合"、"加盐聚合"）是解决这类问题的有效方法。

原理 ：

1. 第一阶段（局部聚合） ：给原始 Key 加上一个随机前缀（或后缀），将热点 Key 的数据打散到不同的 Task。然后，对加盐后的 Key 进行局部聚合。

2. 第二阶段（全局聚合） ：去除随机前缀，对原始 Key 进行最终的全局聚合。

代码对比：优化前 vs 优化后（聚合）

假设我们要统计每个 user_id 的订单总金额。如果 user_id 存在倾斜。

# two_stage_aggregation.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, rand, sum, concat_ws, expr
import time

spark = SparkSession.builder \
    .appName("TwoStageAggregation") \
    .getOrCreate()

# 模拟订单数据，user_id=1000严重倾斜
def create_skewed_orders(spark_session, num_skew_records=100000, num_common_records=50000):
    data = []
    # 倾斜key
    for i in range(num_skew_records):
        data.append((i, 1000, float(i % 200) + 1))
    # 普通key
    for i in range(num_common_records):
        data.append((num_skew_records + i, 1001 + (i % 100), float(i % 100) + 1))
    return spark_session.createDataFrame(data, ["order_id", "user_id", "amount"])

df_orders = create_skewed_orders(spark)
df_orders.cache() # 缓存数据，确保测试公平

print("--- user_id 分布统计 ---")
df_orders.groupBy("user_id").count().orderBy(col("count").desc()).show(5)

# --- 优化前：直接聚合（可能倾斜）---
print("\
--- 优化前：直接聚合 ---")
start_time = time.time()
result_before_optim = df_orders.groupBy("user_id").agg(sum("amount").alias("total_amount"))
result_before_optim.count() # 触发执行
end_time = time.time()
print(f"优化前执行时间: {end_time - start_time:.2f} 秒")
result_before_optim.show(5)

# --- 优化后：两阶段聚合（加盐）---
print("\
--- 优化后：两阶段聚合 ---")
start_time = time.time()

# 阶段1: 局部聚合 - 加随机前缀，打散倾斜Key
# 假设我们知道user_id=1000是热点key，我们可以针对性地加盐。这里为了通用性，对所有key加盐
# 加盐的随机数范围可以根据倾斜程度调整，例如0-99，使得每个热点key的数据被分散到100个Task
salted_df = df_orders.withColumn("salted_user_id", concat_ws("_", col("user_id"), (rand() * 10).cast("int")))

# 对加盐后的Key进行局部聚合
partial_agg_df = salted_df.groupBy("salted_user_id", "user_id") \
                            .agg(sum("amount").alias("partial_amount"))

# 阶段2: 全局聚合 - 去除随机前缀，对原始Key进行最终聚合
final_agg_df = partial_agg_df.groupBy("user_id") \
                               .agg(sum("partial_amount").alias("total_amount"))

final_agg_df.count() # 触发执行
end_time = time.time()
print(f"优化后执行时间: {end_time - start_time:.2f} 秒")
final_agg_df.show(5)

df_orders.unpersist()
spark.stop()

在上述代码中，我们通过 concat_ws("_", col("user_id"), (rand() * 10).cast("int")) 为 user_id 加上了一个 _0 到 _9 的随机后缀，将原本会聚集到一起的 user_id=1000 的数据分散到了 10 个不同的 salted_user_id 组中。这大大减轻了第一阶段聚合的压力。

策略二：Join 操作倾斜处理

Join 操作是 Spark 中最容易发生数据倾斜的地方。以下是几种常用的优化方案。

方案A：广播变量（Broadcast Join）

当其中一个 DataFrame（通常是小表）足够小，可以完全放入所有 Executor 的内存时，可以使用广播变量将小表发送到每个 Executor。这样，Join 操作就不再需要 Shuffle，从而避免了因 Key 分布不均造成的倾斜。

原理 ：将小表复制到每个 Executor 的内存中，大表与小表在本地进行 Join。这把 Shuffle Read 转换为了本地读，效率极高。
适用场景 ：被广播的 DataFrame 大小通常小于几百 MB（由 spark.sql.autoBroadcastJoinThreshold 参数控制）。

# broadcast_join.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, broadcast
import time

spark = SparkSession.builder \
    .appName("BroadcastJoinDemo") \
    .getOrCreate()

# 模拟大表 df_large (存在倾斜key)
large_data = []
for i in range(1000000):
    large_data.append((i, "value_" + str(i % 100), 1000))
# 制造倾斜，user_id=1000的数据量非常大
for i in range(1000000, 2000000):
    large_data.append((i, "value_" + str(i % 50), 1000))

df_large = spark.createDataFrame(large_data, ["id", "data", "user_id"])
df_large.cache()

# 模拟小表 df_small (user_id 数量较少)
small_data = [
    (1000, "Alice", "VIP"), (1001, "Bob", "Normal"),
    (1002, "Charlie", "Normal"), (1003, "David", "Normal")
]
# 确保小表中的倾斜key存在
for i in range(1004, 1100):
    small_data.append((i, f"User_{i}", "Normal"))

df_small = spark.createDataFrame(small_data, ["user_id", "user_name", "user_type"])
df_small.cache()

print("--- user_id 分布统计 (大表) ---")
df_large.groupBy("user_id").count().orderBy(col("count").desc()).show(5)

print("\
--- 优化前：直接Join (可能倾斜) ---")
start_time_normal = time.time()
result_normal_join = df_large.join(df_small, "user_id")
result_normal_join.count() # 触发执行
end_time_normal = time.time()
print(f"优化前执行时间: {end_time_normal - start_time_normal:.2f} 秒")
result_normal_join.show(5)
result_normal_join.explain(True)

print("\
--- 优化后：Broadcast Join ---")
start_time_broadcast = time.time()
# 使用broadcast函数强制广播小表
result_broadcast_join = df_large.join(broadcast(df_small), "user_id")
result_broadcast_join.count() # 触发执行
end_time_broadcast = time.time()
print(f"优化后执行时间: {end_time_broadcast - start_time_broadcast:.2f} 秒")
result_broadcast_join.show(5)
result_broadcast_join.explain(True) # 查看执行计划，会显示BroadcastHashJoin

df_large.unpersist()
df_small.unpersist()
spark.stop()

注意 ：Spark SQL 默认会根据 spark.sql.autoBroadcastJoinThreshold 参数自动判断是否进行广播 Join。如果小表大小超过阈值，即使使用了 broadcast() 函数，Spark 也可能不会执行广播 Join，而是回退到 Sort Merge Join 或 Hash Join，此时可能抛出异常或导致性能下降。

方案B：倾斜 Key 独立处理（热点 Key 分离与加盐）

当无法使用广播 Join，且倾斜问题依然严重时，可以识别出热点 Key，并对这些 Key 进行特殊处理。这是一种更通用的解决方案，尤其适用于大表 Join 大表时。

原理 ：

1. 识别热点 Key ：通过采样或统计分析找出倾斜的 Key。

2. 数据分离 ：将大表（或两张表）分成两部分：包含热点 Key 的数据和不含热点 Key 的数据。

3. 热点 Key 加盐 Join ：给热点 Key 的数据加上随机前缀（或后缀），使其在 Shuffle 阶段被打散。同时，将另一张表中的对应 Key 也进行加盐处理，生成多份，与加盐后的热点数据进行 Join。

4. 非热点 Key 正常 Join ：非倾斜的数据部分进行普通的 Join。

5. 结果合并 ：将两个 Join 的结果 Union 起来。

# salted_join.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, rand, concat_ws, explode, array, desc
import time

spark = SparkSession.builder \
    .appName("SkewedJoinWithSalt") \
    .getOrCreate()

# 模拟两个大表，df_large1 和 df_large2
def create_large_df(spark_session, num_records, num_skew_records, skew_key_val):
    data = []
    # 制造倾斜key
    for i in range(num_skew_records):
        data.append((i, skew_key_val, f"value_{i}"))
    # 制造普通key
    for i in range(num_skew_records, num_records):
        data.append((i, f"key_{(i % 100) + 1}", f"value_{i}"))
    return spark_session.createDataFrame(data, ["id", "join_key", "data_col"])

# 假设 'key_1' 是倾斜key
skew_key = "key_1"
# 倾斜key的数据量可以设定得更大
df_large1 = create_large_df(spark, 2000000, 500000, skew_key)
df_large2 = create_large_df(spark, 1500000, 400000, skew_key)

df_large1.cache()
df_large2.cache()

print("--- join_key 分布统计 (df_large1) ---")
df_large1.groupBy("join_key").count().orderBy(desc("count")).show(5)

print("\
--- 优化前：直接Join ---")
start_time_normal = time.time()
result_normal = df_large1.alias("l1").join(df_large2.alias("l2"), col("l1.join_key") == col("l2.join_key"), "inner")
result_normal.count()
end_time_normal = time.time()
print(f"优化前执行时间: {end_time_normal - start_time_normal:.2f} 秒")

# --- 优化后：热点Key分离与加盐Join ---
print("\
--- 优化后：热点Key分离与加盐Join ---")
start_time_salted = time.time()

# 1. 识别热点Key (这里我们假设已知 skew_key，实际中可以动态识别)
# hot_keys = df_large1.groupBy("join_key").count().filter(col("count") > threshold).collect()
# skew_key_list = [row['join_key'] for row in hot_keys]
# 这里直接使用预设的倾斜key
skew_key_list = [skew_key]
print(f"识别到的热点Key: {skew_key_list}")

# 2. 将 df_large1 分为倾斜部分和非倾斜部分
df_large1_skew = df_large1.filter(col("join_key").isin(skew_key_list))
df_large1_non_skew = df_large1.filter(~col("join_key").isin(skew_key_list))

# 3. 将 df_large2 也分为倾斜部分和非倾斜部分
df_large2_skew = df_large2.filter(col("join_key").isin(skew_key_list))
df_large2_non_skew = df_large2.filter(~col("join_key").isin(skew_key_list))

# 4. 对 df_large1 的倾斜部分进行加盐处理
# 盐的范围可以设大一些，例如0-99，使得热点key能够被充分打散
num_salts = 100
salted_df_large1_skew = df_large1_skew.withColumn("salted_join_key", concat_ws("_", col("join_key"), (rand() * num_salts).cast("int")))

# 5. 对 df_large2 的倾斜部分进行膨胀和加盐处理
# 将每个倾斜key记录复制 num_salts 份，并分别加上不同的盐值
range_array = array(*[lit(i) for i in range(num_salts)])
salted_df_large2_skew = df_large2_skew.withColumn("salt", explode(range_array))
salted_df_large2_skew = salted_df_large2_skew.withColumn("salted_join_key", concat_ws("_", col("join_key"), col("salt"))).drop("salt")

# 6. Join 倾斜部分 (使用新的 salted_join_key)
skewed_joined = salted_df_large1_skew.alias("s1").join(
    salted_df_large2_skew.alias("s2"),
    col("s1.salted_join_key") == col("s2.salted_join_key"),
    "inner"
).select(
    col("s1.id").alias("id1"), col("s1.join_key").alias("join_key"), col("s1.data_col").alias("data_col1"),
    col("s2.id").alias("id2"), col("s2.data_col").alias("data_col2")
)

# 7. Join 非倾斜部分 (正常Join)
non_skewed_joined = df_large1_non_skew.alias("n1").join(
    df_large2_non_skew.alias("n2"),
    col("n1.join_key") == col("n2.join_key"),
    "inner"
).select(
    col("n1.id").alias("id1"), col("n1.join_key").alias("join_key"), col("n1.data_col").alias("data_col1"),
    col("n2.id").alias("id2"), col("n2.data_col").alias("data_col2")
)

# 8. 合并结果
final_result_salted = skewed_joined.unionAll(non_skewed_joined)
final_result_salted.count()
end_time_salted = time.time()
print(f"优化后执行时间: {end_time_salted - start_time_salted:.2f} 秒")
final_result_salted.show(5)

df_large1.unpersist()
df_large2.unpersist()
spark.stop()

这种方法虽然代码量较大，但能有效处理大表之间的 Join 倾斜，尤其是在热点 Key 数量有限但数据量巨大的情况下。

方案C：Spark SQL 内置的 Skew Join 优化 (AQE)

从 Spark 3.0 开始，引入了自适应查询执行（Adaptive Query Execution, AQE），其中包含对 Skew Join 的自动优化。如果 Spark 发现某个 Shuffle 分区的数据量远超其他分区，AQE 会自动将这个倾斜分区进一步拆分，并对拆分后的子分区进行 Join。

原理 ：AQE 在运行时动态调整查询计划。它可以在 Shuffle 过程中检测到倾斜，并自动应用类似加盐的策略，将倾斜分区的数据分散到更多的 Task 中。

如何启用 ：主要通过配置参数 spark.sql.adaptive.enabled 和 spark.sql.adaptive.skewJoin.enabled 来开启。

# aqe_skew_join.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, desc
import time

spark = SparkSession.builder \
    .appName("AQESkewJoinDemo") \
    .config("spark.sql.adaptive.enabled", "true") # 开启AQE
    .config("spark.sql.adaptive.skewJoin.enabled", "true") # 开启AQE的倾斜Join优化
    .config("spark.sql.adaptive.skewJoin.minTelemetryBytes", "256MB") # 检测倾斜分区的最小大小
    .config("spark.sql.adaptive.skewJoin.skewedPartitionFactor", "5") # 倾斜因子，一个分区大小是平均大小的多少倍才算倾斜
    .getOrCreate()

# 模拟两个大表，df_large1 和 df_large2，依然存在倾斜key
def create_large_df(spark_session, num_records, num_skew_records, skew_key_val):
    data = []
    for i in range(num_skew_records):
        data.append((i, skew_key_val, f"value_{i}"))
    for i in range(num_skew_records, num_records):
        data.append((i, f"key_{(i % 100) + 1}", f"value_{i}"))
    return spark_session.createDataFrame(data, ["id", "join_key", "data_col"])

skew_key = "key_1"
df_large1 = create_large_df(spark, 2000000, 500000, skew_key)
df_large2 = create_large_df(spark, 1500000, 400000, skew_key)

df_large1.cache()
df_large2.cache()

print("--- join_key 分布统计 (df_large1) ---")
df_large1.groupBy("join_key").count().orderBy(desc("count")).show(5)

print("\
--- 启用AQE进行Join (自动处理倾斜) ---")
start_time = time.time()
result_aqe_join = df_large1.alias("l1").join(df_large2.alias("l2"), col("l1.join_key") == col("l2.join_key"), "inner")
result_aqe_join.count()
end_time = time.time()
print(f"启用AQE执行时间: {end_time - start_time:.2f} 秒")
result_aqe_join.show(5)
result_aqe_join.explain(True) # 查看执行计划，会显示AdaptiveSparkPlan

df_large1.unpersist()
df_large2.unpersist()
spark.stop()

AQE 是 Spark 3.0+ 的一大亮点，它能显著简化倾斜处理的复杂性，在许多情况下都能自动优化性能。强烈建议在 Spark 3.0+ 版本中开启 AQE。

策略三：处理含有 null 值的 Key

null 值在 Join 或 GroupBy 中也是常见的倾斜源。默认情况下，所有 null 值都会被认为是相等的，并被发送到同一个分区。解决办法是为 null 值赋一个随机值。

代码示例：处理 Join Key 中的 null 值

# handle_null_skew.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, when, rand, concat_ws
import time

spark = SparkSession.builder \
    .appName("HandleNullSkew") \
    .getOrCreate()

# 模拟DataFrame df_a，其中user_id有大量null
data_a = [    (1, 100, "A"), (2, 200, "B"), (3, None, "C"), (4, 400, "D"), (5, None, "E"),]
for i in range(6, 10000):
    data_a.append((i, (i % 50) * 10, "common"))
for i in range(10000, 20000):
    data_a.append((i, None, "null_skew")) # 大量null值

df_a = spark.createDataFrame(data_a, ["id_a", "user_id", "info_a"])

# 模拟DataFrame df_b，其中user_id也有null值
data_b = [
    (100, "X"), (200, "Y"), (300, "Z"), (None, "P"), (400, "Q"),
]
for i in range(401, 500):
    data_b.append((i, "common_b"))
for i in range(500, 5000):
    data_b.append((None, "null_skew_b")) # 大量null值

df_b = spark.createDataFrame(data_b, ["user_id", "info_b"])

print("--- user_id 分布统计 (df_a) ---")
df_a.groupBy("user_id").count().orderBy(col("count").desc()).show(5)

# --- 优化前：直接Join (null值导致倾斜) ---
print("\
--- 优化前：直接Join ---")
start_time_normal = time.time()
result_normal = df_a.join(df_b, "user_id")
result_normal.count()
end_time_normal = time.time()
print(f"优化前执行时间: {end_time_normal - start_time_normal:.2f} 秒")

# --- 优化后：null 值加随机数 ---
print("\
--- 优化后：null 值加随机数 Join ---")
start_time_optimized = time.time()

# 对 df_a 的 user_id 列，如果为null，则替换为随机数
num_salts = 100 # 随机数范围
optimized_df_a = df_a.withColumn(
    "user_id_optimized", 
    when(col("user_id").isNull(), concat_ws("_", lit("null_random"), (rand() * num_salts).cast("int")))
    .otherwise(col("user_id").cast("string")) # 将非null的user_id也转成string，避免类型不匹配
)

# 对 df_b 的 user_id 列，如果为null，也替换为随机数
optimized_df_b = df_b.withColumn(
    "user_id_optimized", 
    when(col("user_id").isNull(), concat_ws("_", lit("null_random"), (rand() * num_salts).cast("int")))
    .otherwise(col("user_id").cast("string"))
)

# 进行Join操作
result_optimized = optimized_df_a.join(optimized_df_b, "user_id_optimized")
result_optimized.count()
end_time_optimized = time.time()
print(f"优化后执行时间: {end_time_optimized - start_time_optimized:.2f} 秒")

# 如果需要恢复原始 user_id，可以在 Join 后再处理
# result_optimized.withColumn("user_id_original", when(col("user_id_optimized").like("null_random_%"), lit(None)).otherwise(col("user_id_optimized")))

spark.stop()

通过将 null 值转换为带有随机后缀的字符串，我们将这些原本会聚集在一起的 null 值分散到不同的分区，从而缓解了倾斜。

第四章：性能优化、常见陷阱与最佳实践

性能对比数据（模拟场景）

我们来模拟一个简单的 Join 场景，并对比不同优化策略的执行时间。请注意，以下数据是模拟的，实际性能会受集群配置、数据量、倾斜程度等多种因素影响。

测试场景 ：两张大表 df_large1 和 df_large2，join_key 存在严重倾斜（key_1 占据 25% 的数据量）。

优化策略	模拟执行时间（秒）	性能提升
直接 Join	~ 45	N/A
加盐 Join	~ 20	~ 55%
AQE Skew Join	~ 18	~ 60%
Broadcast Join	~ 5 (如果小表足够小)	~ 89%

可以看到，针对倾斜采取的优化措施可以带来显著的性能提升。在实际应用中，性能提升幅度可能更大。

常见陷阱和解决方案

1. 盲目增加分区数 ：spark.sql.shuffle.partitions 参数虽然可以增加 Shuffle 的并行度，但如果根本原因是数据倾斜，增加分区数并不能解决少数 Task 处理大量数据的问题，反而可能增加小文件数量和 Shuffle 开销。

   • 解决方案：在解决倾斜的同时，可以适当调整分区数，使其与集群核心数匹配。

2. 过度加盐：如果对非热点 Key 也进行了加盐，或者加盐的随机数范围过大，会导致数据量膨胀，增加 Shuffle 和计算开销。

   • 解决方案：精准识别热点 Key，只对热点 Key 进行加盐。盐值范围适中，根据倾斜程度和集群资源调整。

3. 广播大表 ：试图广播一个超出 Executor 内存上限的 DataFrame 会导致 OOM 错误。

   • 解决方案 ：仔细评估表的实际大小，确保其远小于 spark.sql.autoBroadcastJoinThreshold 或 Executor 内存。

4. 忽视 null 值 ：未处理 null 值作为 Join Key 或 GroupBy Key 导致的倾斜。

   • 解决方案 ：在进行 Join 或 GroupBy 之前，将 null 值替换为随机的、唯一的或特殊的值，以打散这些数据。

最佳实践清单

1. 数据探索与理解：在进行任何优化之前，花时间分析数据分布，找出潜在的热点 Key 和倾斜模式。
2. 利用 Spark UI：熟练使用 Spark UI 诊断工具，它是定位倾斜问题的"黄金标准"。
3. 优先使用 Broadcast Join ：如果其中一张表足够小，毫无疑问应优先考虑 Broadcast Join，它是最简单有效的反倾斜策略。
4. Spark 3.0+ 开启 AQE ：充分利用 Spark 3.0 及其更高版本提供的 Adaptive Query Execution 功能，它能自动检测并缓解多种倾斜问题，显著降低手动优化的复杂性。
5. 加盐策略的权衡 ：当 Broadcast Join 不适用时，考虑加盐策略。可以结合采样和统计分析，只对热点 Key 进行加盐，避免过度加盐的负面影响。
6. 处理 null 值 ：对 Join Key 或 GroupBy Key 中可能存在的 null 值进行预处理，将其替换为随机值或非空占位符。
7. 优化数据类型 ：确保 Join Key 的数据类型一致，避免隐式转换导致的问题。
8. 调整并行度 ：适当增加 spark.sql.shuffle.partitions，但不能完全依赖它解决倾斜问题。并行度应与集群资源和数据量相匹配。

总结与展望：告别Spark数据倾斜困扰

数据倾斜是 Spark 大数据处理中一个绕不开的话题，它直接影响着任务的效率、稳定性和资源利用率。从本文的探讨中，我们学习到：

• 数据倾斜的本质：是分布式任务中数据在少数 Task 上过度聚集，导致这些 Task 成为瓶颈。
• 识别是关键：Spark UI、日志分析和数据统计是识别倾斜的有效手段。
• 策略多样化：针对不同的场景（聚合、Join），我们可以采用两阶段聚合、广播 Join、热点 Key 加盐、AQE 自动优化等多种策略来化解倾斜。

没有一种"银弹"可以解决所有数据倾斜问题。最佳的实践是结合具体业务场景，深入理解数据特征，灵活选择和组合这些优化策略。特别是 Spark 3.0+ 的 AQE 带来了巨大的便利，让倾斜处理变得更加智能。

希望这篇文章能帮助您彻底理解 Spark 数据倾斜的原理，掌握实用的优化技巧，从而更好地驾驭 Spark，编写出高效、稳定的生产级大数据应用！告别那些令人抓狂的卡顿和 OOM，让我们在 Spark 的世界里尽情驰骋吧！