# ReactDOM.render 是如何串联渲染链路的|原理篇

> 本文详细解析了 ReactDOM.render 在 Fiber 架构下的渲染流程，结合源码讲解首次渲染时的初始化、render 阶段和 commit 阶段的执行机制，帮助读者全面理解 React 渲染链路的原理和调用栈分层。

- 原文：https://feinterview.poetries.top/docs/principle-docs/react/19-ReactDOM.render%20%E6%98%AF%E5%A6%82%E4%BD%95%E4%B8%B2%E8%81%94%E6%B8%B2%E6%9F%93%E9%93%BE%E8%B7%AF%E7%9A%84
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.09
- 可见范围：免费部分

---

<!-- principle-learning-suite:start -->
<div class="article-learning-label">文章学习导航</div>

<div class="article-learning-label">面试总览</div>

- 历史入口创建根并提交待渲染内容
- 根更新入队，调度器安排协调工作
- 渲染生成工作树，提交应用宿主变化
- 内部函数名与数据结构随版本变化
- `React 19` 客户端挂载使用 `createRoot`

**`ReactDOM.render` 串起的是建立根、提交更新、计算界面和应用结果这条链。** 在使用它的历史版本里，首次调用初始化根数据，后续调用复用根并更新内容，再进入相应调度与提交流程。内部源码函数帮助理解分工，但不适合当跨版本契约。`React 19` 已移除这个入口，新客户端挂载使用 `createRoot`，已有服务端标记则要考虑水合入口。

**版本校准：** 本文若分析 `ReactDOM.render`、旧生命周期或栈调和，应把它视为理解架构演进的历史路径。`React 19` 已移除 `ReactDOM.render`，当前客户端入口使用 `createRoot`；并发渲染也必须区分可中断的渲染阶段与同步提交阶段。迁移前对照 [React 19 官方升级指南](https://react.dev/blog/2024/04/25/react-19-upgrade-guide)。
<!-- principle-learning-suite:end -->

从本讲开始，我们将以首次渲染为切入点，拆解 Fiber 架构下 `ReactDOM.render` 所触发的渲染链路，结合源码理解整个链路中所涉及的初始化、`render 和 commit` 等过程

## 一、ReactDOM.render 调用栈的逻辑分层

开篇先给到你一个简单的 React AppDemo：

```js
import React from "react";
import ReactDOM from "react-dom";

function App() {
    return (
      <div className="App">
        <div className="container">
          <h1>我是标题</h1>
          <p>我是第一段话</p>
          <p>我是第二段话</p>
        </div>
      </div>
    );
}

const rootElement = document.getElementById("root");
ReactDOM.render(<App />, rootElement);
```

Demo 启动后，渲染出的界面如下图所示：

![](https://s.poetries.top/images/20210501195335.png)

现在请你打开 Chrome 的 `Performance` 面板，点击下图红色圈圈所圈住的这个“记录”按钮：

![](https://s.poetries.top/images/20210501195353.png)

然后重新访问 Demo 页面对应的本地服务地址，待页面刷新后，终止记录，便能够得到如下图右下角所示的这样一个调用栈大图：

![](https://s.poetries.top/images/20210501195414.png)

放大该图，定位“`src/index.js`”这个文件路径，我们就可以找到 `ReactDOM.render` 方法对应的调用栈，如下图所示：

![](https://s.poetries.top/images/20210501195521.png)

从图中你可以看到，`ReactDOM.render` 方法对应的调用栈非常深，中间涉及的函数量也比较大。如果这张图使你心里发虚，请先不要急于撤退——分析调用栈只是我们理解渲染链路的一个手段，我们的目的是借此提取关键逻辑，而非理解调用栈中的每一个方法。就这张图来说，你首先需要把握的，就是整个调用链路中所包含的三个阶段

![](https://s.poetries.top/images/20210501195705.png)

图中 `scheduleUpdateOnFiber` 方法的作用是调度更新，在由 `ReactDOM.render` 发起的首屏渲染这个场景下，它触发的就是 `performSyncWorkOnRoot`。`performSyncWorkOnRoot` 开启的正是我们反复强调的 **render 阶段**；而 `commitRoot` 方法开启的则是真实 DOM 的渲染过程（**commit 阶段**）。因此以 `scheduleUpdateOnFiber` 和 `commitRoot` 两个方法为界，我们可以大致把 `ReactDOM.render` 的调用栈划分为三个阶段：

- 初始化阶段
- `render` 阶段
- `commit` 阶段

## 二、初始化阶段

### 拆解 ReactDOM.render 调用栈——初始化阶段

首先我们提取出初始化过程中涉及的调用栈大图：

![](https://s.poetries.top/images/20210501200309.png)

图中的方法虽然看上去又多又杂，但做的事情清清爽爽，那就是`完成 Fiber 树中基本实体的创建`。

什么是基本实体？基本实体有哪些？问题的答案藏在源码里，这里我为你提取了源码中的关键逻辑，首先是 `legacyRenderSubtreeIntoContainer` 方法。在 `ReactDOM.render` 函数体中，以下面代码所示的姿势调用了它：

```js
return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
```

而 `legacyRenderSubtreeIntoContainer` 的关键逻辑如下（解析在注释里）：

```js
function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
  // container 对应的是我们传入的真实 DOM 对象
  var root = container._reactRootContainer;
  // 初始化 fiberRoot 对象
  var fiberRoot;
  // DOM 对象本身不存在 _reactRootContainer 属性，因此 root 为空
  if (!root) {
    // 若 root 为空，则初始化 _reactRootContainer，并将其值赋值给 root
    root = container._reactRootContainer = legacyCreateRootFromDOMContainer(container, forceHydrate);
    // legacyCreateRootFromDOMContainer 创建出的对象会有一个 _internalRoot 属性，将其赋值给 fiberRoot
    fiberRoot = root._internalRoot;

    // 这里处理的是 ReactDOM.render 入参中的回调函数，你了解即可
    if (typeof callback === 'function') {
      var originalCallback = callback;
      callback = function () {
        var instance = getPublicRootInstance(fiberRoot);
        originalCallback.call(instance);
      };
    } // Initial mount should not be batched.
    // 进入 unbatchedUpdates 方法
    unbatchedUpdates(function () {
      updateContainer(children, fiberRoot, parentComponent, callback);
    });
  } else {
    // else 逻辑处理的是非首次渲染的情况（即更新），其逻辑除了跳过了初始化工作，与楼上基本一致
    fiberRoot = root._internalRoot;
    if (typeof callback === 'function') {
      var _originalCallback = callback;
      callback = function () {
        var instance = getPublicRootInstance(fiberRoot);
        _originalCallback.call(instance);
      };
    } // Update

    updateContainer(children, fiberRoot, parentComponent, callback);
  }
  return getPublicRootInstance(fiberRoot);
}
```

这里我为你总结一下首次渲染过程中 `legacyRenderSubtreeIntoContainer` 方法的主要逻辑链路：

![](https://s.poetries.top/images/20210501201153.png)

在这个流程中，你需要关注到 `fiberRoot` 这个对象。`fiberRoot` 到底是什么呢？这里我将运行时的 `root 和 fiberRoot `为你截取出来，其中 root 对象的结构如下图所示：

![](https://s.poetries.top/images/20210501201231.png)

可以看出，root 对象（`container._reactRootContainer`）上有一个 `_internalRoot` 属性，这个 `_internalRoot` 也就是 `fiberRoot`。fiberRoot 的本质是一个 FiberRootNode 对象，其中包含一个 current 属性，该属性同样需要划重点。这里我为你高亮出 current 属性的部分内容：

![](https://s.poetries.top/images/20210501201327.png)

> 或许你会对 `current` 对象包含的海量属性感到陌生和头大，但这并不妨碍你 Get 到“`current 对象是一个 FiberNode 实例`”这一点，`FiberNode`，正是 `Fiber` 节点对应的对象类型。`current` 对象是一个 `Fiber` 节点，不仅如此，它还是当前 `Fiber` 树的头部节点

考虑到 `current` 属性对应的 `FiberNode` 节点，在调用栈中实际是由 `createHostRootFiber` 方法创建的，React 源码中也有多处以 `rootFiber` 代指 `current` 对象，因此下文中我们将以 `rootFiber 指代 current 对象`。

读到这里，你脑海中应该不难形成一个这样的指向关系：

![](https://s.poetries.top/images/20210501201544.png)

其中，`fiberRoot` 的关联对象是真实 `DOM` 的容器节点；而 `rootFiber` 则作为虚拟 DOM 的根节点存在。这两个节点，将是后续整棵 `Fiber` 树构建的起点。

接下来，`fiberRoot` 将和 `ReactDOM.render` 方法的其他入参一起，被传入 `updateContainer` 方法，从而形成一个回调。这个回调，正是接下来要调用的 `unbatchedUpdates` 方法的入参。我们一起看看 `unbatchedUpdates` 做了什么，下面代码是对 `unbatchedUpdates` 主体逻辑的提取：

```js
function unbatchedUpdates(fn, a) {
  // 这里是对上下文的处理，不必纠结
  var prevExecutionContext = executionContext;
  executionContext &= ~BatchedContext;
  executionContext |= LegacyUnbatchedContext;
  try {
    // 重点在这里，直接调用了传入的回调函数 fn，对应当前链路中的 updateContainer 方法
    return fn(a);
  } finally {
    // finally 逻辑里是对回调队列的处理，此处不用太关注
    executionContext = prevExecutionContext;
    if (executionContext === NoContext) {
      // Flush the immediate callbacks that were scheduled during this batch
      resetRenderTimer();
      flushSyncCallbackQueue();
    }
  }
}
```

在 `unbatchedUpdates` 函数体里，当下你只需要 Get 到一个信息：`它直接调用了传入的回调 fn`。而在当前链路中，fn 是什么呢？fn 是一个针对 `updateContainer` 的调用：

```js
unbatchedUpdates(function () {
  updateContainer(children, fiberRoot, parentComponent, callback);
});
```

接下来我们很有必要去看看 `updateContainer` 里面的逻辑。这里我将主体代码提取如下（解析在注释里，如果没有耐心读完可以直接看文字解读）：

```js
function updateContainer(element, container, parentComponent, callback) {
  ......

  // 这是一个 event 相关的入参，此处不必关注
  var eventTime = requestEventTime();

  ......

  // 这是一个比较关键的入参，lane 表示优先级
  var lane = requestUpdateLane(current$1);
  // 结合 lane（优先级）信息，创建 update 对象，一个 update 对象意味着一个更新
  var update = createUpdate(eventTime, lane); 

  // update 的 payload 对应的是一个 React 元素
  update.payload = {
    element: element
  };

  // 处理 callback，这个 callback 其实就是我们调用 ReactDOM.render 时传入的 callback
  callback = callback === undefined ? null : callback;
  if (callback !== null) {
    {
      if (typeof callback !== 'function') {
        error('render(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callback);
      }
    }
    update.callback = callback;
  }

  // 将 update 入队
  enqueueUpdate(current$1, update);
  // 调度 fiberRoot 
  scheduleUpdateOnFiber(current$1, lane, eventTime);
  // 返回当前节点（fiberRoot）的优先级
  return lane;
}
```

`updateContainer` 的逻辑相对来说丰富了点，但大部分逻辑也是在干杂活，它做的最关键的事情可以总结为三件：

- 请求当前 `Fiber` 节点的 lane（优先级）；
- 结合 `lane`（优先级），创建当前 `Fiber` 节点的 `update` 对象，并将其入队；
- 调度当前节点（`rootFiber`）。

函数体中的 `scheduleWork` 其实就是 `scheduleUpdateOnFiber`，`scheduleUpdateOnFiber` 函数的任务是调度当前节点的更新。在这个函数中，会处理一系列与优先级、打断操作相关的逻辑。但是在 `ReactDOM.render` 发起的首次渲染链路中，这些意义都不大，因为这个渲染过程其实是同步的。我们可以尝试在 Source 面板中为该函数打上断点，逐行执行代码，会发现逻辑最终会走到下图的高亮处：

![](https://s.poetries.top/images/20210501211335.png)

`performSyncWorkOnRoot`直译过来就是“执行根节点的同步任务”，`这里的“同步”二字需要注意，它明示了接下来即将开启的是一个同步的过程`。这也正是为什么在整个渲染链路中，调度（Schedule）动作没有存在感的原因。

前面我们曾经提到过，`performSyncWorkOnRoot` 是 `render` 阶段的起点，`render 阶段`的任务就是完成 `Fiber` 树的构建，它是整个渲染链路中最核心的一环。`在异步渲染的模式下，render 阶段应该是一个可打断的异步过程`

> 而现在，我相信你心里更多的疑惑在于：`都说 Fiber 架构带来的异步渲染是 React 16 的亮点，为什么分析到现在，竟然发现 ReactDOM.render 触发的首次渲染是个同步过程呢`

### 同步的 ReactDOM.render，异步的 ReactDOM.createRoot

其实在 React 16，包括近期发布的 React 17 小版本中，React 都有以下 3 种启动方式：

**legacy 模式：**

`ReactDOM.render(<App />, rootNode)`。这是当前 `React App` 使用的方式，当前没有计划删除本模式，但是这个模式可能不支持这些新功能。

**blocking 模式：**

`ReactDOM.createBlockingRoot(rootNode).render(<App />)`。目前正在实验中，作为迁移到 `concurrent` 模式的第一个步骤

**concurrent 模式：**

`ReactDOM.createRoot(rootNode).render(<App />)`。目前在实验中，未来稳定之后，打算作为 `React `的默认开发模式，这个模式开启了所有的新功能

> 在这 3 种模式中，`我们常用的 ReactDOM.render 对应的是 legacy 模式，它实际触发的仍然是同步的渲染链路`。`blocking` 模式可以理解为 `legacy` 和 `concurrent `之间的一个过渡形态，之所以会有这个模式，是因为 React 官方希望能够提供渐进的迁移策略，帮助我们更加顺滑地过渡到 `Concurrent` 模式。`blocking` 在实际应用中是比较低频的一个模式，了解即可。

按照官方的说法，“`长远来看，模式的数量会收敛，不用考虑不同的模式`，但就目前而言，模式是一项重要的迁移策略，让每个人都能决定自己什么时候迁移，并按照自己的速度进行迁移”。由此可以看出，`Concurrent 模式确实是 React 的终极目标`，也是其创作团队使用 Fiber 架构重写核心算法的动机所在。

### 拓展：关于异步模式下的首次渲染链路

当下，如果想要开启异步渲染，我们需要调用 `ReactDOM.createRoot` 方法来启动应用，那 `ReactDOM.createRoot` 开启的渲染链路与 `ReactDOM.render` 有何不同呢？

这里我修改一下调用方式，给你展示一下调用栈。由于本讲的源码取材于 React 17.0.0 版本，在这个版本中，`createRoot` 仍然是一个 `unstable` 的方法。因此实际调用的 API 应该是“`unstable_createRoot`”：

```js
ReactDOM.unstable_createRoot(rootElement).render(<App />);
```

`Concurrent` 模式开启后，首次渲染的调用栈变成了如下图所示的样子：

![](https://s.poetries.top/images/20210501212348.png)

乍一看，好像和 `ReactDOM.render` 差别很大，其实不然。图中 `createRoot` 所触发的逻辑仍然是一些准备性质的初始化工作，此处不必太纠结。关键在于下面我给你框出来的这部分，如下图所示

![](https://s.poetries.top/images/20210501212616.png)

我们拉近一点来看，如下图所示：

![](https://s.poetries.top/images/20210501212641.png)

你会发现这地方也调用了一个 `render`。再顺着这个调用往下看，发现有大量的熟悉面孔：`updateContainer`、`requestUpdateLane`、`createUpdate`、`scheduleUpdateOnFiber`......这些函数在 `ReactDOM.render` 的调用栈中也出现过。

其实，当前你看到的这个 `render` 调用链路，和 `ReactDOM.render` 的调用链路是非常相似的，主要的区别在 `scheduleUpdateOnFiber` 的这个判断里：

![](https://s.poetries.top/images/20210501212753.png)

在异步渲染模式下，由于请求到的 `lane` 不再是 `SyncLane`（同步优先级），故不会再走到 `performSyncWorkOnRoot` 这个调用，而是会转而执行 `else` 中调度相关的逻辑。

这里有个点要给你点出来——React 是如何知道当前处于哪个模式的呢？我们可以以 `requestUpdateLane` 函数为例，下面是它局部的代码：

```js
function requestUpdateLane(fiber) {
  // 获取 mode 属性
  var mode = fiber.mode;
  // 结合 mode 属性判断当前的
  if ((mode & BlockingMode) === NoMode) {
    return SyncLane;
  } else if ((mode & ConcurrentMode) === NoMode) {
    return getCurrentPriorityLevel() === ImmediatePriority$1 ? SyncLane : SyncBatchedLane;
  }
  ......
  return lane;
}
```

上面代码中需要注意 `fiber`节点上的 `mode` 属性：`React 将会通过修改 mode 属性为不同的值，来标识当前处于哪个渲染模式；在执行过程中，也是通过判断这个属性，来区分不同的渲染模式`。

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/principle-docs/react/19-ReactDOM.render%20%E6%98%AF%E5%A6%82%E4%BD%95%E4%B8%B2%E8%81%94%E6%B8%B2%E6%9F%93%E9%93%BE%E8%B7%AF%E7%9A%84
