几乎每个写 React 的人都撞过这两件事。第一件:
const [count, setCount] = useState(0);
function handleClick() {
setCount(count + 1);
console.log(count); // 还是旧值
}
第二件:改了一个对象的属性,页面纹丝不动。
const [user, setUser] = useState({ name: "张三", age: 18 });
user.age = 19;
setUser(user); // 页面不更新
两个现象看起来都像「React 没反应过来」,其实原因完全不同。第一个是更新被排进了队列,当前这次执行拿到的 count 是渲染时就固定下来的值;第二个是 React 用引用比较判断「变没变」,你改的是同一个对象,引用没变,它认为没变。
这篇把一次更新从触发到落到 DOM 的全过程拆开讲。理解这条链路,你才能知道哪些「不更新」是设计如此、哪些是写法问题,也才知道并发渲染到底在优化哪一段、为什么它救不了另一些卡顿。
先把「异步」这件事测出来
不要停在「setState 是异步的」这句结论上,它不准确,也没法指导你写代码。做一个能复现的观察:
function Counter() {
const [count, setCount] = useState(0);
console.log("render", count);
function handleClick() {
setCount(count + 1);
console.log("点击后立刻读", count);
setTimeout(() => console.log("下一个宏任务里读", count), 0);
}
// ...
}
点一次按钮,控制台会打出「点击后立刻读 0」「render 1」「下一个宏任务里读 0」。第三个输出很有意思:即使等到了下一个宏任务,闭包里读到的还是 0,因为 handleClick 这个函数本身就是上一次渲染创建的,它的作用域里 count 永远是 0。
我的假设是「更新不是同步改值,而是排进队列,等这次事件处理完再统一处理」。验证方式有三个:在组件函数体里数渲染次数;用 flushSync 强制同步刷新再读;在 useEffect 里读最新值。三者的结果能拼出完整图景:
- 组件函数体只执行一次,说明三次连续
setState被合并了; flushSync(() => setCount(1))之后紧跟的 DOM 已经更新,说明刷新本身可以是同步的,只是默认不这么做;useEffect里读到的是新值,说明更新已经提交,只是不在你写setState的那一行。
所以更准确的说法是:setState 只负责「登记一次更新」,什么时候真正重新渲染由调度器决定。默认情况下它会把同一批更新合并,在合适的时机统一处理。
一次更新的三段路
前三步和第四步的性质完全不同,这是理解 React 性能问题的关键分界。
render 阶段是纯计算:执行组件函数、跑 hooks、和上一次的结果做比较、标记出需要变更的节点。它不碰 DOM,所以理论上可以随时暂停、丢弃、重来。并发渲染能做的文章,全在这个阶段。
commit 阶段是真正写 DOM:插入、删除、更新属性、调整顺序,然后执行布局类副作用,最后把控制权交回浏览器去绘制。这一段必须一次做完,中途停下会让页面处于半更新状态。所以哪怕开了并发,一次提交里如果涉及上千个 DOM 节点,该卡还是会卡。
很多「React 性能优化」的讨论混淆了这两段。虚拟列表、减少渲染的组件数、memo,优化的是 render;减少一次提交里的 DOM 操作量,优化的是 commit。前者可以靠调度变得「不阻塞输入」,后者只能靠少干活。
Fiber 与双缓冲
React 16 之后,内部的节点结构叫 Fiber。每个 Fiber 对应一个组件或者一个 DOM 节点,里面存着类型、props、对应的 DOM 引用、父子和兄弟指针,以及这次更新要做的副作用标记。
关键设计是双缓冲:内存里同时存在两棵树,一棵是当前显示在屏幕上的(current),另一棵是正在构建的(workInProgress)。构建新树时复用旧树的节点,通过 alternate 指针互相对应;构建完成后,根指针一换,新树变成 current,旧树留作下一次的草稿。
双缓冲带来两个好处。第一,更新过程中屏幕上的树始终完整,不会出现新旧混在一起的中间态。第二,构建可以中断:被打断时,workInProgress 树就停在那里,下次从根或者从某个边界继续,实在不行整棵丢掉重建,current 树不受影响。
这也解释了为什么「render 阶段不能有副作用」。如果组件函数在 render 时发请求、改全局变量,而这次 render 可能被中断、丢弃、重跑,副作用就会执行多次或者执行在半成品上。useEffect 之所以要单独安排时机,就是为了把副作用挪出这段可重试的计算。
协调:差异是怎么算出来的
React 不会去比对两棵任意树的完整差异,那是代价很高的算法。它用的是同层比较:只比较同一父节点下、同一位置的子节点,类型不同就整棵替换,类型相同就继续往下比。
列表是这条规则里最容易出问题的地方,因为「同一位置」在列表增删之后会变。这时候 key 就派上用场:React 用 key 判断「这个 Fiber 对应的是不是同一个逻辑项」,而不是看它排在第几个。
// 用下标做 key
{items.map((item, i) => <Row key={i} value={item} />)}
// 用稳定 id 做 key
{items.map((item) => <Row key={item.id} value={item} />)}
第一版在删除第一项之后,第二项会挪到第一个位置,但它的 key 从 1 变成 0,React 认为第一个位置「换了个组件」,于是把原来第一项的 Fiber 状态(比如输入框里的内容、展开状态)套到了新数据上。表现出来就是「删了一条,下面的输入框内容跟着串位」。
用稳定 id 做 key,React 才能认出「这个 Fiber 对应的还是原来那条数据」,把状态跟着数据走。代价是 id 必须稳定且唯一,用随机数当 key 会让每次渲染都重建整列,比不写 key 还糟。
类型相同但内容变了,React 会继续往下递归。所以一个组件的 props 变了,它自己会重新执行;父组件重新执行,子组件默认也会重新执行,除非子组件被 memo 包住且 props 浅比较相等。这也解释了为什么「只改了一个小状态,整棵树都在渲染」:默认行为就是自上而下重新计算。
Hooks 为什么不能写在条件里
函数组件每次渲染都会重新执行一遍,局部变量全部重建。那 useState 怎么能记住上一次的值?因为 hook 的状态不存在组件函数的闭包里,而是存在对应的 Fiber 上,按调用顺序排成一条链表。
第一次渲染时,每调用一个 hook,就在链表尾部加一个节点;后续渲染时,按同样的顺序从头遍历,把状态取出来。所以 hook 的「身份」完全由调用顺序决定。如果你在某个分支里跳过了一个 hook,后面所有 hook 都会错位:本该拿 count 的位置拿到了 name。
function Bad({ show }) {
if (show) {
const [a, setA] = useState(1); // 顺序会变,后续 hook 全部错位
}
const [b, setB] = useState(2);
}
知道了这一点,另一个常见困惑也能解释:为什么 useEffect 里拿到的总是旧值。effect 回调是在当次渲染时创建的,它捕获的是那一次渲染的 props 和 state。如果依赖数组没写对,回调就不会重新创建,于是一直在用第一次渲染时的闭包。
useEffect(() => {
const timer = setInterval(() => {
console.log(count); // 永远是 0
setCount(count + 1); // 永远设成 1
}, 1000);
return () => clearInterval(timer);
}, []); // 依赖漏了 count
把更新写成函数式 setCount(c => c + 1) 能解决「设错值」,但解决不了「读到旧值」。真要在定时器里读最新状态,要么把依赖补上让 effect 重建,要么用 ref 保存最新值。前者会频繁清理定时器,后者更常见。
依赖数组的正确写法是「回调里用到的所有响应式值都列出来」,但也不能把每次渲染都新建的对象放进去,否则依赖每次都不相等,effect 会白跑。这条规则靠人记很容易错,后面讲 React Compiler 时你会看到另一种思路:让构建工具去分析,而不是靠人维护依赖列表。
批处理、优先级与并发
React 18 之前,只有在 React 事件处理函数里的多次 setState 会被合并;写在 setTimeout、Promise 回调里的更新会各自触发一次渲染。React 18 把这个行为统一了:同一轮事件循环里的更新都会自动批处理,不管你写在哪儿。
setTimeout(() => {
setCount(c => c + 1);
setFlag(f => !f);
setName("x");
}, 0); // React 18 里只渲染一次
合并的目的是减少重复计算和重复提交。但它也意味着「我调了三次,为什么只渲染一次」是预期行为,不是 bug。确实需要每次更新都立刻生效的场景(比如要同步读 DOM),用 flushSync 包住,代价是失去合并带来的性能收益。
优先级是另一层。React 18 用 lanes 这套位掩码模型给更新分组:用户输入、点击这类要立刻响应的算紧急;路由切换、列表过滤这类可以稍后算过渡。startTransition 和 useDeferredValue 就是把工作标成过渡优先级的入口。
const [query, setQuery] = useState("");
const deferredQuery = useDeferredValue(query);
const list = useMemo(() => filterHugeList(deferredQuery), [deferredQuery]);
<input value={query} onChange={(e) => setQuery(e.target.value)} />
输入框用的是最新的 query,列表用的是滞后的 deferredQuery。用户打字时,输入框的更新是紧急的,先提交;列表的重算被标成过渡,可以被打断、被更新的输入作废。表现出来就是「输入不卡了,列表稍微慢半拍」。useTransition 还会额外给你一个 isPending 标志,用来在列表还没跟上时显示一个轻微的加载态,避免界面看起来「卡住了但没反应」。
调度器本身也值得说一句。React 不直接依赖浏览器的空闲回调,而是把自己的工作放进内部任务队列,用消息通道把执行切成小段,每段结束后检查是否该让给更紧急的任务。这样做的原因是:空闲回调只在浏览器完全没事的时候才来,而 React 需要在输入到来前尽快推进,不能干等。但无论怎么切,你自己写的同步循环仍然是这段调度里不可分割的一个单元。
这里要泼一盆冷水:并发渲染不是多线程,所有计算仍然在主线程上。它做的是把长任务切成小块,在块与块之间检查有没有更紧急的事要做。filterHugeList 本身如果是一次不可分割的同步循环,React 切不开它,照样会卡。并发能优化的是「很多组件各自渲染」这种可切分的工作,不是单次重计算。
现象、机制、怎么自己验证
| 现象 | 真实机制 | 怎么验证 |
|---|---|---|
setState 之后立刻读 state 还是旧值 |
更新被登记进队列,当前函数闭包里的 state 是这次渲染时固定下来的 | 用函数式更新对比;在 useEffect 里打印新值;用 flushSync 强制同步后再读 |
一次事件里调三次 setState,组件只渲染一次 |
React 18 自动批处理,同一轮事件循环里的更新合并成一次渲染 | 在组件函数体累加计数器;把其中一次包进 flushSync,观察渲染次数变化 |
| 修改对象属性后页面不更新 | 更新时用 Object.is 比较新旧 state,引用相同就跳过 |
改成返回新对象再试;打印修改前后的引用,确认是同一个 |
| 列表用下标当 key,删除首项后输入框内容错位 | key 决定 Fiber 的复用关系,下标会让状态跟着位置走而不是跟着数据走 | 换成数据 id 做 key,重复删除操作对比;用 React DevTools 看 Fiber 的 key |
开发环境里 useEffect 执行了两次 |
StrictMode 在开发环境故意双调用渲染和 effect,用来暴露副作用问题 | 临时关掉 StrictMode 对比;用生产构建再跑一次 |
| 大列表过滤时输入明显卡顿 | 每次输入都同步走完 render 和 commit,主线程被占满 | 用 Profiler 录一次输入,看 render 与 commit 的耗时;改用 useDeferredValue 再对比 |
| 接入外部状态库后,并发渲染下偶尔显示不一致 | render 被中断后重新读取了已变化的外部值,两段 UI 来自不同时刻 | 换成 useSyncExternalStore 订阅,或者在过渡更新期间高频改动外部值复现 |
边界与代价
commit 不可中断,这是硬边界。 一次更新涉及大量 DOM 操作、复杂布局、同步测量的场景,并发帮不上忙。该做的是减少一次提交的量:虚拟滚动、分批渲染、把重活挪到 requestIdleCallback 或者 Worker。别指望加个 startTransition 就能让一千个节点插入变快。
并发渲染不是免费的。 为了能中断和恢复,React 要维护两棵树、记录优先级、做更多的簿记工作。在小页面上,这些开销可以忽略;在极端场景下,开启并发反而比同步模式多一些总计算量。它换的是响应性,不是吞吐量。
memo 和 useMemo 有维护成本。 浅比较本身要遍历 props,缓存要占内存,依赖数组写错会拿到旧值。给一个渲染很便宜的组件加 memo,收益可能是负的。判断标准是 Profiler 里这个组件确实占了大头,而不是「感觉它应该被缓存」。
Context 的更新会穿透 memo。 一个 Provider 的 value 变了,所有消费它的组件都会重新渲染,中间夹着的 memo 拦不住。常见的错误是把整个大对象放进一个 Context,任何一个字段变化都引发全局重渲染。拆成多个 Context,或者改用外部状态库按字段订阅,是更实际的做法。
外部状态与并发渲染的兼容性要单独考虑。 自己手写订阅、在 render 里读可变的外部对象,在可中断渲染下可能出现两段 UI 来自不同时刻的问题。React 提供 useSyncExternalStore 就是为了处理这件事。用第三方状态库时,留意它是否适配了并发渲染。
StrictMode 的双调用不是故障。 它在开发环境重复执行渲染和 effect,目的是让你看见「副作用被执行两次会怎样」。为它加各种防重锁,等于把真实问题藏起来。正确的做法是让副作用可清理、可重入。
SSR 下水合前后不是同一套生命周期。 服务端不会执行 useEffect,首屏依赖 effect 的逻辑在服务端拿不到结果。数据要在渲染阶段准备好,或者交给框架的数据层。这也是上一篇里 mismatch 的常见来源之一。
今天就能动手的实验
- 在组件函数体里累加一个计数器并打印,事件里连调三次
setState,确认只渲染一次;再把其中一次包进flushSync,看次数变化。 - 做一个带输入框的列表,先用下标做 key,删除第一项观察输入内容是否串位;换成 id 再试一次。
- 用 React DevTools 的 Profiler 录一次点击,分别看 render 和 commit 的耗时条,判断瓶颈在哪一段。
- 做一个几千项的过滤列表,先用普通 state 更新,再用
useDeferredValue,对比输入时的掉帧情况。 - 写一个
setInterval里读count的例子,复现永远读到 0;再用 ref 保存最新值修好。
小结
startTransition 都是围绕「让紧急更新先落地」设计的。它们优化响应性,不减少总计算量,也不是多线程。下一篇讲Vue 响应式系统。React 的思路是「状态变了,我重新算一遍,再靠比较找出差异」;Vue 走的是另一条路——在读写属性的时候就把依赖记下来,变化发生时精确通知。两条路解决同一个问题,代价却完全不同。看完 React 的显式调度,再去看 Vue 的自动追踪,会更容易看清各自的取舍。