> **摘要**：Spark Worker 是 Standalone 集群中每台节点上的"大管家"。它负责向 Master 注册签到、每 15 秒发送心跳、接收 Master 指令 fork Executor 和 DriverWrapper 进程、实时追踪本节点的 CPU/内存资源余量、并在进程退出时回收资源。但 Worker 有一个"反直觉"的特点——它完全不参与 Task 调度。本文从 Worker 内部架构全景、核心数据结构、进程 fork 管理、资源追踪模型、完整生命周期五个维度，配合 1 张原创深色架构图 + 完整源码分析，带你彻底看清 Worker 的内部世界。
>
> **关键词**：Spark Worker, ProcessBuilder, CoarseGrainedExecutorBackend, coresFree, LaunchExecutor, 心跳, 资源管理

---

## 一、开篇：Worker 是什么？

如果 Master 是集群的"指挥中心"，Worker 就是每台节点上的"执行总管"。

| 职责 | 说明 |
|------|------|
| **向 Master 注册** | 启动时上报 host/port/cores/memory |
| **心跳上报** | 每 15 秒告知 Master 自己还活着 |
| **fork 进程** | 接收 Master 指令，通过 ProcessBuilder 启动 Executor/Driver JVM |
| **资源追踪** | 实时维护 coresFree 和 memoryFree |
| **进程监控** | 监控子进程退出 → 自动回收资源 |

**关键特点**：Worker 不参与 Task 调度——Task 由 Driver 直连 Executor RPC 发送。

---

## 二、Worker 内部架构全景图
![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-2482016/bf672985462a548f2d61e12727e6ab79.png)

## 三、核心数据结构

```scala
// 源码：Worker.scala
private[worker] class Worker(
    override val rpcEnv: RpcEnv,
    webUiPort: Int,
    cores: Int,          // Worker 分配给 Spark 的总核心数
    memory: Int,          // Worker 分配给 Spark 的总内存
    masterRpcAddresses: Array[RpcAddress],
    ...
) extends ThreadSafeRpcEndpoint {

  // === 核心数据结构 ===
  val executors = new HashMap[String, ExecutorRunner]  // 运行中的 Executor
  val drivers = new HashMap[String, DriverRunner]      // 运行的 Driver (Cluster)
  
  var coresFree = cores      // 可用核心数
  var memoryFree = memory    // 可用内存
  
  var master: Option[RpcEndpointRef] = None  // Master RPC 引用
}
```

| 数据结构 | 类型 | 用途 |
|----------|------|------|
| `executors` | HashMap | 运行中的 Executor，Key=executorId |
| `drivers` | HashMap | Cluster 模式的 DriverWrapper |
| `coresFree` | Int | 剩余可用核心 |
| `memoryFree` | Int | 剩余可用内存 |
| `master` | RpcEndpointRef | 与 Master 的 RPC 连接 |

---

## 四、进程 fork 管理 🔥

这是 Worker 最核心的功能——接收 Master 指令，通过 ProcessBuilder 启动新 JVM。

### 4.1 LaunchExecutor 处理

```scala
// 源码：Worker.scala - 接收 Master 启动 Executor 指令
case LaunchExecutor(masterUrl, appId, execId, appDesc, cores_, memory_) =>
  // 1. 创建 ExecutorRunner
  val manager = new ExecutorRunner(
    appId, execId, appDesc, cores_, memory_,
    self, workerId, host, webUiPort, publicAddress, sparkHome, executorDir, ...)
  
  // 2. 记录到 executors 映射
  executors(appId + "/" + execId) = manager
  
  // 3. 启动 Executor 子进程
  manager.start()
  
  // 4. 扣减本节点可用资源
  coresFree -= cores_
  memoryFree -= memory_
  
  // 5. 向 Master 汇报最新状态
  masterRef.send(ExecutorStateChanged(appId, execId, manager.state, None, None))
```

### 4.2 ExecutorRunner：真正的 ProcessBuilder

```scala
// 源码：ExecutorRunner.scala - start()
def start(): Unit = {
  val builder = new ProcessBuilder(
    "java",
    "-cp", "spark-assembly.jar",
    "org.apache.spark.executor.CoarseGrainedExecutorBackend",
    "--driver-url", driverUrl,    // Driver RPC 地址
    "--executor-id", execId,
    "--cores", cores.toString,
    "--memory", memory.toString,
    "--hostname", host
  )
  
  val process = builder.start()
  
  // 监控进程退出
  new Thread("ExecutorMonitor") {
    override def run(): Unit = {
      process.waitFor()
      // → 通知 Worker 回收资源
      worker.send(ExecutorStateChanged(appId, execId, ExecutorState.EXITED, ...))
    }
  }.start()
}
```

### 4.3 KillExecutor 处理

```scala
case KillExecutor(masterUrl, appId, execId) =>
  executors.get(appId + "/" + execId).foreach { executor =>
    executor.kill()          // 终止子进程
    coresFree += executor.cores    // 归还核心
    memoryFree += executor.memory  // 归还内存
    executors -= (appId + "/" + execId)
  }
  masterRef.send(ExecutorStateChanged(appId, execId, ExecutorState.KILLED, ...))
```

---

## 五、Worker 完整生命周期

```
Phase 1: 启动 → 向 Master 发送 RegisterWorker
   ├── 上报 host/port/cores/memory
   └── Master 返回 RegisteredWorker (含 masterUrl)

Phase 2: 心跳循环 (15s)
   ├── 每次心跳携带 coresFree/memoryFree 等状态
   ├── 同时汇报当前 executors/drivers 列表
   └── Master 据此更新全局资源视图

Phase 3: 接收 Master 指令 (RPC)
   ├── LaunchExecutor → fork Executor JVM
   ├── KillExecutor  → 终止 Executor + 回收资源
   ├── LaunchDriver  → fork DriverWrapper (Cluster)
   └── KillDriver    → 终止 DriverWrapper

Phase 4: 进程退出监控
   ├── ExecutorRunner 监视线程捕获子进程 exit
   ├── 通知 Worker → 通知 Master → 回收资源
   └── Master 重新 schedule() 其他任务

Phase 5: Worker 关闭
   ├── Kill 全部 Executor + Driver
   ├── 向 Master 发送 UnregisterWorker
   └── JVM 退出
```

---

## 六、Worker vs YARN NodeManager 对比

| 维度 | Spark Worker | YARN NodeManager |
|------|-------------|-----------------|
| 资源抽象 | 直接管理 JVM 进程 | Container (CPU+内存) |
| 资源隔离 | 无（纯 JVM 级别） | Linux Cgroup |
| 多租户 | ❌ | ✅ YARN Queue |
| 进程管理 | ProcessBuilder | ContainerExecutor |
| 适用规模 | 中小集群 | 大规模生产 |
| 复杂度 | 简单 | 复杂（完整容器生命周期） |

---

## 七、总结

| 要点 | 总结 |
|------|------|
| **定位** | Worker = 单节点资源管理者，JVM 进程 |
| **核心职责** | fork/kill Executor 和 Driver 进程 |
| **资源追踪** | coresFree + memoryFree 实时维护 |
| **不参与调度** | Task 由 Driver 直连 Executor RPC |

> **金句**：Master 说"启动一个 Executor"，Worker 就 fork 一个新 JVM；Master 说"杀了它"，Worker 就关闭那个进程。Worker 是 Spark 集群中最忠实的执行者——它不问为什么，只管执行。

---

<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>

摘要：Spark Worker 是 Standalone 集群中每台节点上的"大管家"。它负责向 Master 注册签到、每 15 秒发送心跳、接收 Master 指令 fork Executor 和 DriverWrapper 进程、实时追踪本节点的 CPU/内存资源余量、并在进程退出时回收资源。但 Worker 有一个"反直觉"的特点——它完全不参与 Task 调度。本文从 Worker 内部架构全景、核心数据结构、进程 fork 管理、资源追踪模型、完整生命周期五个维度，配合 1 张原创深色架构图 + 完整源码分析，带你彻底看清 Worker 的内部世界。

Spark 核心之 Worker 原理剖析

摘要：Spark Worker 是 Standalone 集群中每台节点上的"大管家"。它负责向 Master 注册签到、每 15 秒发送心跳、接收 Master 指令 fork Executor 和 DriverWrapper 进程、实时追踪本节点的 CPU/内存资源余量、并在进程退出时回收资源。但 Worker 有一个"反直觉"的特点——它完全不参与 Task 调度。本文从 Worker 内部

人工智能

SparkWorker作为Standalone集群节点核心组件，负责向Master注册、每15秒发送心跳、通过ProcessBuilder管理Executor和DriverWrapper进程生命周期，并实时追踪CPU/内存资源余量。Worker不参与Task调度，专注于进程级管理和资源监控。本文深入剖析Worker内部架构、数据结构、进程fork机制、资源追踪模型及完整生命周期，配合源码分析揭示其"执行总管"的本质特征。

数据架构

数据结构

代码解释

大数据

LangGraph

容器

GitHub

Spark 

Java

让每一个 Agent，都跑在云上

bigdata-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

SparkWorker作为Standalone集群节点核心组件，负责向Master注册、每15秒发送心跳、通过ProcessBuilder管理Executor和DriverWrapper进程生命周期，并实时追踪CPU/内存资源余量。Worker不参与Task调度，专注于进程级管理和资源监控。本文深入剖析Worker内部...

Spark 核心之 Worker 原理剖析-腾讯云开发者社区-腾讯云

Spark 核心之 Worker 原理剖析

Spark 核心之 Worker 原理剖析

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐