6.1.1.3 大数据方法论与实践指南-SparkStreaming 任务优化实践

6.1.1.3 SparkStreaming 任务优化实践

Spark Streaming 是 Spark 生态中用于实时流处理的组件，其性能优化需要从资源分配、并行度、数据倾斜、反压控制、序列化、GC 调优等多个维度进行综合优化。本文结合生产环境实践，总结 Spark Streaming 的优化策略和案例。

一、核心优化方向

资源分配优化

Spark Streaming 的资源分配直接影响任务吞吐量和延迟，需合理配置 Executor 数量、内存、CPU 核心数。

（1）Executor 配置

|-------------------|----------------|-----------------------|
| 参数 | 说明 | 推荐值 |
| --num-executors | Executor 数量 | 根据集群资源分配（如 5~20 个） |
| --executor-memory | 单 Executor 内存 | 4~16GB（避免过大导致 GC 停顿） |
| --executor-cores | 单 Executor 核心数 | 2~5 核（留 1 核给系统进程） |
| --driver-memory | Driver 内存 | 2~4GB（处理少量聚合数据时） |

点击图片可查看完整电子表格

（2）资源分配实践

避免内存浪费：Executor 内存过大（如 30GB+）会导致 GC 停顿，建议拆分为多个小 Executor（如 10GB × 3 个优于 30GB × 1 个）。

CPU 核心数：每个 Executor 核心数过多会导致线程竞争，建议 2～5 核（如 spark.executor.cores=3）。

动态资源分配：启用 spark.dynamicAllocation.enabled=true，根据负载自动调整 Executor 数量。

并行度优化

并行度直接影响 Spark Streaming 的处理能力，需合理设置分区数、并行度。

（1）分区数匹配

Kafka 分区数 ≥ Spark Streaming 并行度：确保每个 Kafka 分区由一个 Spark Task 处理，避免数据倾斜。

手动调整分区数：

|----------------------------------------------|
| Scala dstream.repartition(20) // 增加分区数以提高并行度 |

（2）并行度设置

全局并行度：

|--------------------------------------------------------------------------------|
| Scala sparkConf.set("spark.default.parallelism", "100") // 默认等于 Executor 核心数总和 |

DStream 并行度：

|----------------------------------------------------------------------|
| Scala dstream.transform(rdd => rdd.repartition(50)) // 对每个批次的数据重新分区 |

数据倾斜优化

数据倾斜会导致部分 Task 处理时间过长，拖慢整个批次的处理速度。常见优化方法：

（1）两阶段聚合

（2）加盐打散

对倾斜的 Key 添加随机前缀（如 key_1， key_2），处理后合并：

|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Scala val saltedKeys = dstream.flatMap { case (key, value) => if (key == "hot-key") { // 倾斜的 Key (1 to 10).map(i => (s" ${key}_$ i", value / 10)) // 分散到 10 个子 Key } else { Seq((key, value)) } } val aggregated = saltedKeys.reduceByKey(_ + ) // 局部聚合 val finalResult = aggregated.map { case (saltedKey, value) => val originalKey = saltedKey.split("")(0) // 恢复原始 Key (originalKey, value) }.reduceByKey(_ + _) // 全局聚合 |

（3）倾斜 Key 单独处理

将倾斜的 Key 单独提取出来，用单独的 Task 处理：

|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Scala val (normalData, hotData) = dstream.mapPartitions { iter => val (normal, hot) = iter.partition(_.1 != "hot-key") (normal.toList, hot.toList) }.persist() val normalAgg = normalData.reduceByKey( + ) val hotAgg = hotData.mapPartitions(iter => iter.map { case (key, value) => (key, value * 2) }) // 单独处理 .reduceByKey( + ) val finalResult = normalAgg.union(hotAgg).reduceByKey( + _) |

反压控制（Backpressure）

Spark Streaming 的反压机制可以动态调整数据摄入速率，避免任务积压。

（1）启用反压

|-------------------------------------------------------------------------------------------------------------------------------------------------------|
| Scala sparkConf.set("spark.streaming.backpressure.enabled", "true") // 启用反压 sparkConf.set("spark.streaming.backpressure.initialRate", "1000") // 初始速率 |

（2）动态调整速率

Spark 2.3+ 支持动态调整速率（pidRateEstimator），根据系统负载自动调整批次处理量。

监控指标：

Processing Delay：批次处理延迟（streamingContext.remember(Minutes(60)) 保留历史数据）。

Scheduling Delay：调度延迟（反映集群负载）。

Input Rate：数据摄入速率（与 Backpressure 联动）。

序列化优化

Spark Streaming 的序列化方式直接影响网络传输和磁盘 I/O 性能。

（1）使用 Kryo 序列化

|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Scala sparkConf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer") sparkConf.registerKryoClasses(Array(classOf[MyCustomClass])) // 注册自定义类 |

（2）避免序列化大对象

避免在 map 或 filter 中返回大对象（如 Array[Byte]），改用 Dataset 或 DataFrame 处理二进制数据。

GC 优化

Spark Streaming 的 GC 停顿会导致批次处理延迟，需优化 JVM 参数。

（1）选择 GC 算法

G1 GC（推荐）：

|-------------------------------------------------------------------------------------|
| Bash --conf "spark.executor.extraJavaOptions=-XX:+UseG1GC -XX:MaxGCPauseMillis=200" |

CMS GC（旧版 Spark）：

|-------------------------------------------------------------------------------------------------------------|
| Bash --conf "spark.executor.extraJavaOptions=-XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70" |

（2）调整新生代大小

避免频繁 Full GC：

|----------------------------------------------------------------|
| Bash --conf "spark.executor.extraJavaOptions=-Xmn2g" # 新生代 2GB |

（3）避免对象创建

重用对象（如使用 ObjectPool 缓存频繁创建的对象）。

使用 fastutil 或 Koloboke 替代 Java 集合类。

Checkpoint 优化

Checkpoint 用于故障恢复，但过度使用会影响性能。

（1）合理设置 Checkpoint 间隔

（2）避免 Checkpoint 过大

减少 updateStateByKey 或 mapWithState 的状态大小。

使用 RocksDB 存储大状态（需配置 spark.locality.wait=0s 避免本地化等待）。

二、生产环境优化案例

案例 1：Kafka 数据倾斜导致批次延迟

问题：某 Spark Streaming 任务处理 Kafka 数据时，部分批次延迟高达 10 分钟，监控发现 90% 的 Task 在 10 秒内完成，但少数 Task 处理时间超过 5 分钟。

优化方案：

检查数据分布：发现某个 Key（如 user_id=12345）的数据量占 80%。

加盐打散：

|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Scala val saltedData = dstream.flatMap { case (key, value) => if (key == "hot-key") { (1 to 10).map(i => (s" ${key}_$ i", value / 10)) } else { Seq((key, value)) } } |

调整并行度：

|------------------------------------------------------|
| Scala saltedData.repartition(100).reduceByKey(_ + _) |

效果：批次处理延迟从 10 分钟降至 2 分钟，Task 处理时间均匀分布。

案例 2：GC 停顿导致批次超时

问题：某任务频繁出现 Full GC，导致批次处理时间超过 5 分钟（超时阈值）。

优化方案：

切换到 G1 GC：

|-------------------------------------------------------------------------------------|
| Bash --conf "spark.executor.extraJavaOptions=-XX:+UseG1GC -XX:MaxGCPauseMillis=200" |

调整新生代大小：

|------------------------------------------------------|
| Bash --conf "spark.executor.extraJavaOptions=-Xmn2g" |

减少对象创建：改用 Dataset 替代 RDD 处理数据。

效果：Full GC 频率从每分钟 1 次降至每 10 分钟 1 次，批次处理时间稳定在 2 分钟内。

三、总结

|------------|-------------------------------------------|---------------------------------------------------------------------------------|
| 优化方向 | 关键策略 | 示例 |
| 资源分配 | 合理配置 Executor 内存/核心数 | --executor-memory=8g --executor-cores=3 |
| 并行度 | 匹配 Kafka 分区数，调整 spark.default.parallelism | dstream.repartition(100) |
| 数据倾斜 | 两阶段聚合、加盐打散 | (key % 10, value) |
| 反压控制 | 启用 spark.streaming.backpressure.enabled | sparkConf.set("spark.streaming.backpressure.enabled", "true") |
| 序列化 | 使用 Kryo 序列化 | sparkConf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer") |
| GC 优化 | 使用 G1 GC，调整新生代大小 | -XX:+UseG1GC -Xmn2g |
| Checkpoint | 合理设置 Checkpoint 间隔 | sparkConf.set("spark.streaming.checkpoint.duration", "60") |

点击图片可查看完整电子表格

通过综合优化，Spark Streaming 任务的吞吐量可提升 3～5 倍，批次处理延迟降低 50%～80%，适应生产环境的高并发、低延迟需求。