Spark重要特性和机制


发布于 2025-07-23 / 11 阅读 / 0 评论 /
Spark中重要的机制和特性介绍

1.RDD

RDD(Resilient Distributed Dataset,弹性分布式数据集) 是 Spark 最核心的数据抽象,可以理解为「分布在集群多台机器上的、只读的、可分区的、可容错的数据集合」。

Resilient(弹性/容错):通过血缘(Lineage)机制,某个分区丢失后可自动重算恢复,无需像 Hadoop 那样做数据复制或检查点

Distributed(分布式):数据分布在集群多个节点上,天然支持并行计算

Dataset(数据集):一个只读的数据集合,不可变(Immutable)

1.1.RDD的核心特性

一个 RDD 本质上由以下五个属性构成(对应源码中的 RDD 抽象类):

特性

说明

函数说明

分区列表(Partitions)

数据被切分成多个分区,分布到不同节点并行计算

def getPartitions: Array[Partition]

计算函数(Compute)

每个分区如何计算(compute 方法)

def compute(split: Partition, context: TaskContext): Iterator[T]

依赖列表(Dependencies)

记录与其他 RDD 的依赖关系(窄/宽依赖),用于构建血缘

def getDependencies: Seq[Dependency[_]] = deps

分区器(Partitioner)

可选,针对 KV 型 RDD,决定数据如何分区(如 HashPartitioner)

@transient val partitioner: Option[Partitioner] = None

首选位置(Preferred Locations)

每个分区的数据优先在哪些节点计算(数据本地性)

def getPreferredLocations(split: Partition): Seq[String] = Nil

1.2.RDD的核心特点

RDD包含以下四个核心特点:

(1)只读、不可变(Immutable)

RDD 一旦创建就不能修改。任何「转换」操作(如 map、filter)都会生成一个新的 RDD,而不是修改原 RDD。

(2)惰性求值(Lazy Evaluation)

转换操作(Transformation)不会立即执行,只是记录计算逻辑;只有遇到行动操作(Action,如 count、collect、save)时才真正触发计算。

(3)血缘与容错(Lineage)

RDD 记录了它是如何从父 RDD 一步步转换来的(依赖链)。某个分区的数据丢失时,可以沿着血缘链重新计算该分区,而不是从头重跑整个作业。

(4)内存计算

数据优先缓存在内存中(配合 persist/cache),避免反复读写磁盘,这是 Spark 比 MapReduce 快的重要原因。

1.3.RDD算子类型

RDD的compute函数可分为以下两种算子:

(1)转换操作算子 Transformation

返回新的 RDD,惰性执行,不触发计算,包括:map / filter / flatMap / reduceByKey / groupByKey……

(2)行动操作算子 Action

返回结果或写出数据,触发真正的计算,包括:count / collect / reduce / saveAsTextFile / foreach……

1.4.RDD依赖类型

RDD依赖类型分为两种:

(1)窄依赖(Narrow Dependency)

父 RDD 的每个分区,最多被一个子 RDD 分区使用。可以在同一个 Stage 内流水线(Pipeline)执行,无需 Shuffle。

例如:map、filter、union

(2)宽依赖(Wide/Shuffle Dependency)

父 RDD 的一个分区,会被多个子 RDD 分区使用。必须产生 Shuffle,成为 Stage 的切分边界。

例如:reduceByKey、groupByKey、join

2.Spark vs Flink vs MapReduce

三种计算引擎的定位不同

计算引擎

定位

计算范式

MapReduce

第一代批处理框架

Map + Shuffle + Reduce 两阶段模型

Spark

内存批处理框架(微批流)

DAG 弹性数据集(RDD)模型

Flink

真正的流处理框架(流批一体)

有状态的流式数据流模型

计算引擎核心维度对比

维度

MapReduce

Spark

Flink

计算模型

Map/Reduce 两阶段

RDD DAG + Stage 流水线

有状态流式 DataStream/算子链

处理模式

纯批处理

批处理为主,微批模拟流

原生流处理,批是流的有界特例

延迟

分钟/小时级(高)

秒级(微批流,中)

毫秒级(低,真流式)

中间结果

强制落盘 HDFS

优先内存(可溢写磁盘)

内存 + 状态后端

容错机制

数据落盘 + 重算

血缘(Lineage)+ 重算/checkpoint

分布式快照(Chandy-Lamport)+ 精确一次

吞吐量

中

高

高(流场景极优)

内存使用

几乎不依赖内存

重度依赖内存

依赖内存(可配置状态后端)

开发语言/API

Java(低级冗长)

Scala/Java/Python/R(高级简洁)

Java/Scala/Python

SQL 支持

Hive on MR

Spark SQL

Flink SQL

机器学习/图

无

MLlib/GraphX

FlinkML(较弱)

精确一次(Exactly-Once)

批处理天然

批天然,流较难

内置 Exactly-Once

事件时间/乱序处理

不支持

支持但有限

原生支持(Watermark)

不同计算引擎的适用场景如下表所示:

场景

推荐计算引擎

理由

大规模离线批处理(TB 级日志 ETL、报表)

Spark(或 MR)

Spark 快;MR 极稳定

迭代计算(机器学习、图计算)

Spark

内存缓存中间结果,避免反复落盘

实时流处理(实时风控、监控告警、实时大屏)

Flink

毫秒级低延迟、真流式、Exactly-Once

事件时间/乱序/复杂窗口(物联网、金融交易)

Flink

原生 Watermark 机制

SQL 分析/数据仓库(批)

Spark SQL

生态成熟,SQL 优化器强

实时 SQL 分析(流)

Flink SQL

流批一体,支持实时数仓

统一批流一体平台

Flink(趋势)或 Spark(当前生态更全)

视团队技术栈

遗留/极低成本离线任务

MapReduce

资源要求低,历史系统兼容

选型要点总结

(1)纯离线批处理 + 需要丰富生态(SQL/ML/Graph) → Spark

(2)实时流处理 / 低延迟 / Exactly-Once / 复杂事件时间 → Flink

(3)大规模离线 + 追求极致稳定性 + 资源受限 / 历史系统 → MapReduce

(4)流批一体统一平台 → 优先 Flink(技术趋势),若团队已有 Spark 生态可继续用 Spark Structured Streaming 过渡

3.Spark数据本地性调度

Spark 通过 getPreferredLocations 让每个 RDD 分区声明"我最好在哪里读",调度器用五级本地性 + 延迟调度在"等待更本地资源"和"及时启动任务"之间做权衡,把任务尽量"黏"在数据旁;任务运行时,读取器再按 executorId/host 分流,本地块直接读磁盘/内存,只有真正跨节点的块才走网络。两层配合,最大化削减网络 shuffle 与磁盘 I/O。

本地块读取(Local Fetch)

入口 BlockStoreShuffleReader.read() → ShuffleBlockFetcherIterator

菱形分流 partitionBlocksByFetchMode,按 (executorId, host) 分成三条路径:

  • local:executorId == 本机 → 本地磁盘/内存直读,不走网络

  • host-local:同节点不同 Executor → 同节点本地目录读

  • remote:其他 → Netty 网络拉取

3.1.本地性级别

本地性有5个级别

级别

含义

数据位置

PROCESS_LOCAL

同 Executor 进程

数据已在本进程内存 / 本地磁盘缓存

NODE_LOCAL

同节点、不同 Executor

数据在节点本地磁盘(如 HDFS block 本机)

NO_PREF

无位置偏好

如读 HDFS 无偏好、或结果数据

RACK_LOCAL

同机架

数据在同机架其他节点

ANY

任意位置

数据需要跨机架网络传输

3.2.Delay Scheduling(延迟调度)算法

核心就是用「少量延迟」换取「大量网络传输的节省」。

每个本地级别都有一个默认 3 秒的等待窗口。如果当前只有 ANY 级别的资源可用,Spark 会拒绝这次 offer、等待更本地的资源出现;只有当等待时间超过该级别阈值,才降级到更远的级别。

从图上可知,延迟调度四步流程:资源 Offer → 计算允许级别 → 按优先级出队 → 匹配成功本地执行 / 失败则拒绝并等待

4.Spark SQL通用优化方法

Spark SQL 优化本质是围绕一句话展开:减少数据扫描量、减少 Shuffle、避免数据倾斜、提升资源利用率。下面按"从易到难、从通用到进阶"梳理一套可落地的优化方法。

4.1.执行计划层面优化

首先,看执行计划

EXPLAIN COST <SQL>;        -- 看物理计划 + 代价
EXPLAIN EXTENDED <SQL>;    -- 看详细计划(含裁剪、谓词下推)

关注点:是否全表扫描、是否走了 BroadcastHashJoin、Filter 是否下推、是否发生不必要的 Shuffle。

然后,参考核心优化点进行优化。

优化点

说明

优化方法

谓词下推

Filter 提前到数据源执行

通常自动,注意 UDF 可能阻止下推

列裁剪

只读需要的列

避免 SELECT *

分区裁剪

只读需要的分区

WHERE 条件要命中分区字段

Join 顺序调整

小表在前

用 CBO 或 hint

4.2.Join 优化

这是最常见、收益最大的优化方法。具体的措施如下

(1)优先让小表走广播(BroadcastHashJoin)

使用方法如下

-- 默认 spark.sql.autoBroadcastJoinThreshold = 10MB
-- 小表(<10MB)自动广播;超限时手动 hint
SELECT /*+ BROADCAST(b) */ ... FROM 大表 a JOIN 小表 b ON a.id = b.id;

广播 Join 避免 Shuffle,是收益最大的优化之一

可调大阈值:spark.sql.autoBroadcastJoinThreshold = 100MB(需保证 Driver/Executor 内存够)

(2)避免大表 Join 大表(必要时优化)

用 Skew Join 处理倾斜。

用 Bucket Join(分桶表)减少 Shuffle。

(3)优先用 SortMergeJoin 还是 BroadcastJoin?

可参考下表进行选择

场景

推荐

小表 join 大表

BroadcastHashJoin

两个大表

SortMergeJoin(默认)

两表都分桶且桶数相同

Bucketed Join(免 Shuffle)

4.3.数据倾斜优化

这是重点和难点,按照以下步骤进行

(1)识别倾斜

可以查看key的分布,如果key分布不均,则必定倾斜。

-- 看 key 分布
SELECT key, count(*) cnt FROM table GROUP BY key ORDER BY cnt DESC LIMIT 10;

或在 Spark UI → Stage → Task 的 Duration 分布,少数 Task 极慢 = 倾斜。

(2)常见解法

根据不同的场景选择解法

场景

方案

Join 倾斜

1.给热点 key 加随机前缀打散

2.spark.sql.adaptive.skewJoin.enabled=true(AQE 自动处理)

GroupBy 倾斜

1.两阶段聚合(局部预聚合 + 全局聚合)

2.加盐打散

大 key 倾斜

把热点 key 单独拎出来处理,非热点正常处理,再 union

(3)开启 AQE(自适应查询执行,强烈推荐)

开启的配置如下:

spark.sql.adaptive.enabled = true                    # 开启 AQE
spark.sql.adaptive.coalescePartitions.enabled = true # 自动合并小分区
spark.sql.adaptive.skewJoin.enabled = true           # 自动处理倾斜 Join
spark.sql.adaptive.skewJoin.skewedPartitionFactor = 5

AQE 是 Spark 3.0+ 的利器,能运行时动态调整分区数、处理倾斜、优化 Join 策略,默认应开启。

4.4.Shuffle 优化

spark难免也会遇到shuffle,可参考以下优化点

优化点

配置/方法

说明

减少 Shuffle 次数

合并算子、复用结果

能一次做完别拆两次

Shuffle 分区数合理

spark.sql.shuffle.partitions

默认 200,需按数据量调(小任务调小,大任务调大)

Shuffle 压缩

spark.shuffle.compress=true

减少网络/磁盘 IO

Map 端聚合

reduceByKey 代替 groupByKey

map 端先聚合,减少 shuffle 数据量

避免不必要的 Shuffle

用广播、宽依赖改窄依赖

-

4.5.资源配置优化

大部分时候,资源配置可以起到最明显的优化效果

# Executor 配置(按集群资源调整)
spark.executor.memory = 8g
spark.executor.cores = 4
spark.executor.instances = 20
spark.driver.memory = 4g

# 动态资源分配(推荐)
spark.dynamicAllocation.enabled = true
spark.dynamicAllocation.minExecutors = 5
spark.dynamicAllocation.maxExecutors = 50

有以下经验法则:

(1)Executor 核数不宜过多(3~5 核最优,太多会争抢)

(2)内存分三块:执行内存 + 存储内存 + 用户内存(默认 60% 给执行+存储)

(3)开启动态分配,按负载伸缩

4.6.存储格式与文件优化

有以下优化点

优化点

优化方法

列式存储

优先 Parquet / ORC(列裁剪 + 压缩)

压缩

snappy / zstd 平衡压缩比与速度

分区表

合理分区,避免分区过多(分区数过多会拖慢元数据扫描)

分桶表

Bucket 表配合 Bucket Join 免 Shuffle

小文件合并

大量小文件会导致任务碎片化,用 coalesce/repartition 或合并小文件

合理分区数

单分区数据量建议 128MB~256MB(HDFS block 大小)

4.7.SQL 写法优化

常用的sql写法优化参考下表

写法问题

优化方法

SELECT *

只 select 需要的列

在过滤列上用函数

改写让条件直接作用在列上

groupByKey

用 reduceByKey

笛卡尔积

避免,或先过滤再 join

大表 collect()

避免 collect 大结果到 Driver

例如

-- ❌ 避免
SELECT * FROM t;                          -- 不用列裁剪
SELECT count(*) FROM t GROUP BY 1;        -- 隐式类型转换
WHERE func(col) = x                       -- 列上套函数,阻止下推/索引

-- ✅ 推荐
SELECT col1, col2 FROM t;
WHERE col = x AND dt = '20240101'         -- 条件命中分区字段

4.8.元数据与统计信息优化

统计信息过期是"计划变差"的常见根因(结合之前值班案例)。数据大量变化后,及时 ANALYZE。

-- 更新统计信息(优化器依据它做 CBO 决策)
ANALYZE TABLE t COMPUTE STATISTICS;
ANALYZE TABLE t COMPUTE STATISTICS FOR COLUMNS col1, col2;

-- 开启 CBO(基于代价优化)
spark.sql.cbo.enabled = true
spark.sql.statistics.histogram.enabled = true

4.9.其他高频优化点

其他高频优化点参考下表

优化点

说明

缓存

反复使用的 DataFrame 用 .cache() / .persist(),选好 StorageLevel

序列化

spark.serializer=org.apache.spark.serializer.KryoSerializer

本地性

合理设置 spark.locality.wait,提升数据本地读

推测执行

慢任务 spark.speculation=true 兜底(慎用,会浪费资源)

广播大变量

大字典/配置文件用广播变量,避免每个 Task 序列化一份

避免 UDF

优先用内置函数,UDF 阻止优化(Spark 3.x 可用 Pandas UDF / 内置函数替代)

5.Spark动态内存分配

如下图所示:

spark.memory.storageFraction = 0.5 只是一个初始占比,不是硬上限——它只在初始阶段划分 Storage 和 Execution 的起点。

Execution 可以无限度抢占 Storage(通过驱逐缓存),因为 Execution 的数据是易失的、用完即弃,优先级最高。

Storage 不能反过来抢占 Execution 已占用的内存,只能捡空闲,且要随时归还——这保证了计算永远不会被缓存"饿死",体现了"计算优先于缓存"的设计哲学。