> **摘要**：为什么 `map().filter()` 可以在一个 Stage 内完成，而 `reduceByKey()` 必须切分新的 Stage？为什么 Shuffle 是 Spark 性能的头号杀手？答案就在 RDD 的依赖类型之中——NarrowDependency 与 ShuffleDependency。本文从依赖类型体系、Stage 边界判定源码、Pipeline 优化原理、容错策略差异、性能影响与调优五个维度，配合 1 张原创深色架构图 + 完整源码分析，带你彻底理解 Spark 最核心的概念之一。
>
> **关键词**：Spark RDD, NarrowDependency, ShuffleDependency, Stage, Pipeline, 血缘, 容错, Shuffle

---

## 一、开篇：为什么依赖类型决定一切？

先看两段等价代码：

```scala
// 方案 A: 全 Narrow — 1 个 Stage, 无 Shuffle
rdd.map(_ + 1).filter(_ > 10).collect()

// 方案 B: 包含 Wide — 2 个 Stage, 有 Shuffle
rdd.map(_ + 1).reduceByKey(_ + _).collect()
```

**方案 A 只有 1 个 Stage**，因为 `map` 和 `filter` 都是窄依赖——子 Partition 只依赖父 Partition 的 1 对 1 映射，Spark 可以将它们 **Pipeline 在一起** 执行。

**方案 B 有 2 个 Stage**，因为 `reduceByKey` 是宽依赖——子 Partition 需要从多个父 Partition 拉取数据，必须通过 Shuffle 重新分区。

---

## 二、NarrowDependency vs ShuffleDependency 全景图

![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-2482016/e3e852fde1c21dcbb8822ee6ab1b2d5c.png)

## 三、NarrowDependency（窄依赖）

### 3.1 三种子类型

```scala
// 源码：Dependency.scala
abstract class NarrowDependency[T](_rdd: RDD[T]) extends Dependency[T] {
  // 子 Partition 依赖父 RDD 的哪些 Partition
  def getParents(partitionId: Int): Seq[Int]
}

// 1:1 映射
class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd) {
  override def getParents(partitionId: Int) = List(partitionId)
}

// Range 依赖 (union)
class RangeDependency[T](rdd: RDD[T], inStart: Int, outStart: Int, length: Int)
  extends NarrowDependency[T](rdd) {
  override def getParents(partitionId: Int) =
    if (partitionId >= outStart && partitionId < outStart + length)
      List(partitionId - outStart + inStart) else Nil
}
```

### 3.2 哪些算子产生 NarrowDependency？

| 算子 | 依赖类型 | 说明 |
|------|----------|------|
| `map` | OneToOneDependency | 1→1 映射 |
| `filter` | OneToOneDependency | 1→1 映射（过滤后仍独立） |
| `flatMap` | OneToOneDependency | 1→1 映射 |
| `mapPartitions` | OneToOneDependency | 1→1 映射 |
| `union` | RangeDependency | 多 RDD 拼接 |
| `coalesce` | NarrowDependency | 减少 Partition（不涉及 Shuffle 时） |
| `sample` | OneToOneDependency | 采样 |

---

## 四、ShuffleDependency（宽依赖）

### 4.1 源码结构

```scala
class ShuffleDependency[K, V, C](
    @transient private val _rdd: RDD[_ <: Product2[K, V]],
    val partitioner: Partitioner,        // HashPartitioner / RangePartitioner
    val serializer: Serializer = SparkEnv.get.serializer,
    val keyOrdering: Option[Ordering[K]] = None,
    val aggregator: Option[Aggregator[K, V, C]] = None, // mapSideCombine
    val mapSideCombine: Boolean = false)
  extends Dependency[Product2[K, V]] {
  val shuffleId: Int = _rdd.context.newShuffleId()
  val shuffleHandle: ShuffleHandle = ... // SortShuffleManager 生成
}
```

### 4.2 ShuffleDependency 的五个关键属性

| 属性 | 说明 | 影响 |
|------|------|------|
| **partitioner** | HashPartitioner / RangePartitioner | 决定数据如何分布到下游 Partition |
| **serializer** | Kryo / Java | 序列化 Shuffle 中间数据 |
| **keyOrdering** | 排序器 | sortByKey 必须指定 |
| **aggregator** | 聚合器 | reduceByKey 的 mapSideCombine |
| **mapSideCombine** | 是否 Map 端预聚合 | **reduceByKey vs groupByKey 的关键区别** |

### 4.3 reduceByKey vs groupByKey

```scala
// ❌ groupByKey: mapSideCombine=false — 全量数据传输
rdd.groupByKey()  // Shuffle 传输所有 KV 对

// ✅ reduceByKey: mapSideCombine=true — Map 端预聚合
rdd.reduceByKey(_ + _)  // Shuffle 前先在 Map 端合并
```

**性能差异**：`reduceByKey` 比 `groupByKey` 减少 90%+ 的 Shuffle 数据量（取决于 Key 的重复率）。

---

## 五、依赖类型决定 Stage 边界

```scala
// 源码：DAGScheduler.scala
private def getOrCreateParentStages(rdd: RDD[_], firstJobId: Int): List[Stage] = {
  rdd.dependencies.flatMap {
    case shufDep: ShuffleDependency[_, _, _] =>
      // 🔥 遇到 Shuffle → 创建 ShuffleMapStage → Stage 边界
      getOrCreateShuffleMapStage(shufDep, firstJobId) :: Nil
    case _: NarrowDependency[_] =>
      Nil  // Narrow → 同 Stage, 不切分
  }.toList
}
```

**规则**：遇到 `ShuffleDependency` 即切分 Stage，`NarrowDependency` 全部在同一 Stage 内 Pipeline 执行。

---

## 六、容错策略差异

| 维度 | Narrow | Wide |
|------|--------|------|
| **容错范围** | 只重算丢失 Partition | 重算整个 Stage（因为上游数据需要重新 Shuffle） |
| **血缘链** | 短（Pipeline 内） | 长（跨 Stage） |
| **恢复成本** | 低 | **高**（Shuffle 重复 I/O） |
| **Checkpoint** | 通常不需要 | **强烈建议**在 Shuffle 后 Checkpoint |

---

## 七、性能优化建议

```bash
# 1. 用 reduceByKey 代替 groupByKey（开启 mapSideCombine）
# 2. 用 Kryo 序列化减少 Shuffle 数据量
--conf spark.serializer=org.apache.spark.serializer.KryoSerializer

# 3. 调大 Shuffle 分区数避免数据倾斜
--conf spark.sql.shuffle.partitions=400

# 4. 启用 Shuffle 文件合并
--conf spark.shuffle.consolidateFiles=true
```

---

## 八、总结

| 要点 | 总结 |
|------|------|
| **NarrowDependency** | 1→1 / Range / Prune, 同 Stage Pipeline, 容错轻 |
| **ShuffleDependency** | 多→多, Stage 边界, Shuffle I/O 重, 容错贵 |
| **Stage 切分** | 遇 ShuffleDependency 即切分 |
| **优化核心** | 减少 Shuffle = 减少 Stage = 提升性能 |

> **金句**：Narrow 是团队内部的接力赛（一棒接一棒，全在一个 Stage），Wide 是部门之间的邮件沟通（必须写好 Shuffle 文件，下一个 Stage 再来读）。

---

<p style="margin-top:20px;padding-top:10px;border-top:1px solid #eee;font-size:14px;color:#999;text-align:center;line-height:2;">
作者：starzy  |  AI Data Engineer / 大数据技术实践者<br/>
博客：blog.starzy.cn  |  GitHub：starzy1990.github.io<br/>
专注 AI Agent · LangGraph · RAG · 大数据架构 · 数据工程实践
</p>

摘要：为什么 map().filter() 可以在一个 Stage 内完成，而 reduceByKey() 必须切分新的 Stage？为什么 Shuffle 是 Spark 性能的头号杀手？答案就在 RDD 的依赖类型之中——NarrowDependency 与 ShuffleDependency。本文从依赖类型体系、Stage 边界判定源码、Pipeline 优化原理、容错策略差异、性能影响与调优五个维度，配合 1 张原创深色架构图 + 完整源码分析，带你彻底理解 Spark 最核心的概念之一。

Spark 核心之 RDD 窄依赖与宽依赖详解

摘要：为什么 map().filter() 可以在一个 Stage 内完成，而 reduceByKey() 必须切分新的 Stage？为什么 Shuffle 是 Spark 性能的头号杀手？答案就在 RDD 的依赖类型之中——NarrowDependency 与 ShuffleDependency。本文从依赖类型体系、Stage 边界判定源码、Pipeline 优化原理、容错策略差异、性能影响与调

大数据

架构设计

本文深入解析Spark RDD依赖类型：窄依赖（NarrowDependency）与宽依赖（ShuffleDependency）如何决定Stage边界与性能。通过源码分析map/filter同Stage Pipeline执行原理，对比reduceByKey与groupByKey的Shuffle开销差异，提供容错策略与调优建议，助你掌握Spark性能优化的核心。

数据架构

代码解释

LangGraph

GitHub

Spark 

Java

2026上云采购 | AI焕新·智启新局

bigdata-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

本文深入解析Spark RDD依赖类型：窄依赖（NarrowDependency）与宽依赖（ShuffleDependency）如何决定Stage边界与性能。通过源码分析map/filter同Stage Pipeline执行原理，对比reduceByKey与groupByKey的Shuffle开销差异，提供容错策略与调...

Spark 核心之 RDD 窄依赖与宽依赖详解-腾讯云开发者社区-腾讯云

Spark 核心之 RDD 窄依赖与宽依赖详解

Spark 核心之 RDD 窄依赖与宽依赖详解

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐