渲染与 IPC 性能

本章目标

  • 理解 Chromium 渲染流水线与帧预算,能判断「掉帧」发生在哪一段。
  • 掌握长列表、大图、动画、重排重绘的优化手段。
  • 能治理主进程阻塞与高频 IPC 带来的界面卡顿。
  • 制定团队可执行的渲染性能标准。

帧预算

人眼感知流畅的最低标准通常是 60fps,即每帧 16.67ms。高刷新率屏幕(90/120Hz)对应 11.1ms / 8.3ms。

一帧内要完成:

任何一段超预算,就会出现掉帧。主线程被长任务占用时,输入事件也无法及时处理,表现为「点了没反应」。

帧率单帧预算常见场景
60fps16.67ms普通桌面
90fps11.11ms高刷屏
120fps8.33ms高刷屏、动画密集

渲染指标

指标含义采集
FPS每秒绘制帧数requestAnimationFrame 统计
长任务数超过 50ms 的主线程任务PerformanceObserver('longtask')
掉帧率超出帧预算的帧占比帧间隔统计
INP交互到下一次绘制PerformanceObserver('event')
首屏 LCP最大内容绘制PerformanceObserver('largest-contentful-paint')

采集 FPS 与掉帧

1// src/renderer/perf/fps.ts
2export function observeFps(durationMs = 5000): Promise<{
3  fps: number;
4  droppedRatio: number;
5}> {
6  return new Promise((resolve) => {
7    const frameBudget = 1000 / 60;
8    let frames = 0;
9    let dropped = 0;
10    let last = performance.now();
11    const start = last;
12
13    const tick = (now: number): void => {
14      const delta = now - last;
15      last = now;
16      frames += 1;
17
18      if (delta > frameBudget * 1.5) {
19        dropped += 1;
20      }
21
22      if (now - start < durationMs) {
23        requestAnimationFrame(tick);
24      } else {
25        const elapsed = now - start;
26        resolve({
27          fps: Math.round((frames / elapsed) * 1000),
28          droppedRatio: Number((dropped / frames).toFixed(3)),
29        });
30      }
31    };
32
33    requestAnimationFrame(tick);
34  });
35}

长任务

1new PerformanceObserver((list) => {
2  for (const entry of list.getEntries()) {
3    console.warn('long task', entry.startTime, entry.duration);
4  }
5}).observe({ type: 'longtask', buffered: true });

长任务超过 50ms 就会明显影响交互。优化目标不是「消灭所有长任务」,而是把关键路径上的长任务拆到 50ms 以下。

DevTools 定位掉帧

  1. 打开 Performance 面板,勾选 Screenshots。
  2. 录制一段卡顿操作。
  3. 看 Main 线程的火焰图:
    • 黄色:JS 执行。
    • 紫色:样式与布局。
    • 绿色:绘制与合成。
  4. 看 Frames 轨道是否有红色三角(掉帧)。
  5. 看 Bottom-Up / Call Tree,定位最耗时的函数。

Rendering 面板可以开启:

  • Paint flashing:哪些区域在重绘。
  • Layout Shift Regions:布局偏移。
  • Frame rendering stats:FPS 与 GPU 信息。
  • Layer borders:合成层边界。

长列表

一次性渲染上万行 DOM 是典型卡顿源。解决方案是虚拟列表:只渲染可视区域。

1// src/renderer/components/VirtualList.tsx
2import { useMemo, useRef, useState } from 'react';
3
4type VirtualListProps<T> = {
5  items: T[];
6  itemHeight: number;
7  height: number;
8  renderItem: (item: T, index: number) => React.ReactNode;
9};
10
11export function VirtualList<T>({ items, itemHeight, height, renderItem }: VirtualListProps<T>) {
12  const [scrollTop, setScrollTop] = useState(0);
13  const ref = useRef<HTMLDivElement>(null);
14
15  const visibleCount = Math.ceil(height / itemHeight);
16  const start = Math.max(0, Math.floor(scrollTop / itemHeight) - 3);
17  const end = Math.min(items.length, start + visibleCount + 6);
18
19  const visible = useMemo(() => items.slice(start, end), [items, start, end]);
20
21  return (
22    <div
23      ref={ref}
24      style={{ height, overflowY: 'auto' }}
25      onScroll={(e) => setScrollTop(e.currentTarget.scrollTop)}
26    >
27      <div style={{ height: items.length * itemHeight, position: 'relative' }}>
28        {visible.map((item, i) => (
29          <div
30            key={start + i}
31            style={{
32              position: 'absolute',
33              top: (start + i) * itemHeight,
34              height: itemHeight,
35              left: 0,
36              right: 0,
37            }}
38          >
39            {renderItem(item, start + i)}
40          </div>
41        ))}
42      </div>
43    </div>
44  );
45}

优化点:

  • 只渲染可视区 + 少量缓冲。
  • 固定行高时用绝对定位,避免布局抖动。
  • 滚动事件只更新 scrollTop,不要触发数据请求。
  • 图片懒加载,离开视口释放。
  • 复杂单元格使用 React.memo 或缓存。

CSS 辅助:

1.list-row {
2  content-visibility: auto;
3  contain-intrinsic-size: 48px;
4}

content-visibility: auto 让浏览器跳过屏幕外内容的渲染,适合中等规模列表;超大规模仍应使用虚拟列表。

大图与动画

图片

  • 使用正确尺寸,不要在 100×100 的容器里渲染 4000×4000。
  • 优先 WebP/AVIF,减少解码内存与时间。
  • 大图使用 loading="lazy" 或 IntersectionObserver。
  • 避免在滚动中同步解码大图。
1const observer = new IntersectionObserver((entries) => {
2  for (const entry of entries) {
3    if (entry.isIntersecting) {
4      const img = entry.target as HTMLImageElement;
5      img.src = img.dataset.src ?? '';
6      observer.unobserve(img);
7    }
8  }
9});
10
11document.querySelectorAll('img[data-src]').forEach((img) => observer.observe(img));

动画

优先使用合成层动画:

1.panel {
2  transition: transform 200ms ease, opacity 200ms ease;
3  will-change: transform;
4}
  • transform / opacity 通常只触发合成,不触发布局与绘制。
  • 避免动画 width、height、top、left、margin。
  • will-change 要慎用,滥用会创建过多合成层,增加 GPU 内存。
  • 动画结束后移除 will-change。
1element.addEventListener('transitionend', () => {
2  element.style.willChange = 'auto';
3}, { once: true });

使用requestAnimationFrame 驱动

1let rafId = 0;
2let value = 0;
3
4function animate(): void {
5  value = Math.min(1, value + 0.02);
6  element.style.transform = `translateX(${value * 200}px)`;
7  if (value < 1) {
8    rafId = requestAnimationFrame(animate);
9  }
10}
11
12rafId = requestAnimationFrame(animate);
13
14// 取消
15cancelAnimationFrame(rafId);

不要在动画循环里做布局读取(offsetHeight、getBoundingClientRect),否则会强制同步布局。

重排与重绘

布局抖动

1// 错误:读-写-读-写交替,强制多次同步布局
2for (const el of elements) {
3  el.style.width = `${el.offsetWidth + 10}px`;
4}

修复:先读后写。

1const widths = elements.map((el) => el.offsetWidth);
2elements.forEach((el, i) => {
3  el.style.width = `${widths[i] + 10}px`;
4});

批量 DOM 操作

1const fragment = document.createDocumentFragment();
2for (const item of items) {
3  const li = document.createElement('li');
4  li.textContent = item;
5  fragment.appendChild(li);
6}
7list.appendChild(fragment);

减少选择器与层级

  • 避免深层嵌套与复杂选择器。
  • 使用 contain: layout paint 隔离局部布局影响。
  • 固定尺寸元素显式设置宽高,减少布局计算。

主进程阻塞治理

渲染进程卡顿不一定是渲染层的问题。主进程被阻塞时,IPC 返回变慢,页面等待数据,表现同样是卡顿。

把重任务移出主进程

1// 主进程只做转发
2ipcMain.handle('report:parse', async (_event, filePath: string) => {
3  return parseInUtility(filePath);
4});
1// utility 进程执行解析
2process.parentPort.on('message', async (event) => {
3  const { filePath } = event.data;
4  const result = await parseLargeFile(filePath);
5  process.parentPort.postMessage({ ok: true, result });
6});

避免同步 I/O

1// 禁止
2const content = fs.readFileSync(path, 'utf-8');
3
4// 推荐
5const content = await fs.readFile(path, 'utf-8');

控制日志与序列化

主进程里对大对象做 JSON.stringify 也会阻塞。日志要采样、截断,避免在热路径上输出完整对象。

IPC 性能

减少往返次数

1// 不推荐:循环调用
2for (const id of ids) {
3  await window.api.invoke('item:get', { id });
4}
5
6// 推荐:批量
7await window.api.invoke('item:getMany', { ids });

按帧合并高频事件

1let pending: Array<{ x: number; y: number }> = [];
2let scheduled = false;
3
4window.addEventListener('pointermove', (e) => {
5  pending.push({ x: e.clientX, y: e.clientY });
6  if (scheduled) return;
7  scheduled = true;
8  requestAnimationFrame(() => {
9    void window.api.invoke('pointer:batch', { points: pending });
10    pending = [];
11    scheduled = false;
12  });
13});

大对象与二进制

  • 传路径/ID,不传完整内容。
  • 二进制使用 ArrayBuffer 或 MessagePort。
  • 大列表分页,避免一次序列化几十 MB。

避免同步 IPC

sendSync 会让渲染进程等待主进程,主进程一忙就掉帧。新代码中禁止使用。

多窗口与 GPU 压力

  • 每个窗口都是独立渲染进程,内存与 CPU 成本叠加。
  • 多个窗口同时播放动画会争抢 GPU 与合成资源。
  • 后台窗口应降低渲染频率:
1win.webContents.setBackgroundThrottling(true);
  • 隐藏窗口暂停非必要动画与轮询。
  • 透明窗口、复杂阴影、模糊效果会增加合成成本。

渲染性能标准

一套可落地的团队标准:

指标目标测量方式
常规滚动 FPS≥ 55requestAnimationFrame 采样
动画 FPS≥ 58Performance 面板
长任务关键路径无 > 100ms 任务longtask
INP< 200msPerformanceObserver('event')
首屏 LCP符合产品预算largest-contentful-paint
内存增量操作 20 次后 < 基线 10%app.getAppMetrics()

标准要写进:

  1. 组件库的性能约定(例如列表必须使用虚拟滚动)。
  2. Code Review 检查项。
  3. CI 自动化场景。
  4. 版本发布前的性能验收。

案例:从 30fps 到 60fps 的排查路径

以下为方法示例,数据为示意:

  1. 复现:打开含 5000 行数据的表格,滚动时明显卡顿。
  2. 录制:Performance 面板显示每帧 JS 执行 20–30ms,Layout 8ms。
  3. 定位:滚动事件里每次都 setState 全量数据,触发整表重渲染。
  4. 修复:
    • 改为虚拟列表,只渲染可视行。
    • 滚动状态与数据状态分离。
    • 单元格使用 React.memo。
    • 图片懒加载。
  5. 验证:FPS 从约 30 提升到 55–60,长任务从每帧 1 个降为偶发。
  6. 防回归:把「5000 行滚动 10 秒」加入自动化性能场景。

这个路径适用于大多数渲染性能问题:先测量,再定位到具体阶段,最后用最小改动验证收益。

本章小结

  • 60fps 的预算是 16.67ms,任何一段流水线超时都会掉帧。
  • 长列表用虚拟滚动,大图按尺寸加载,动画优先使用 transform/opacity。
  • 避免布局抖动与频繁 DOM 重建,读写分离、批量更新。
  • 主进程阻塞会通过 IPC 传导为界面卡顿,重任务要移到 utility 进程。
  • 渲染性能标准要数字化,并进入评审与 CI。

参考资料