内存与 GC 优化

本章目标

  • 分清 Electron 应用的内存组成:Node 堆、V8 堆、GPU 内存、Native 内存。
  • 会用 app.getAppMetrics()、堆快照、DevTools Memory 定位泄漏。
  • 掌握常见泄漏模式与修复方式。
  • 把「内存 < 300MB」拆成进程级预算,并建立回归门禁。

内存都去哪了

组成观察方式典型问题
主进程 V8 堆process.memoryUsage()全局缓存、日志、未释放对象
主进程 Native 内存系统监视器原生模块泄漏、Buffer 未释放
渲染进程 V8 堆DevTools Memory闭包、事件监听、DOM 引用
GPU/纹理app.getAppMetrics()、GPU 面板大图、动画层、透明窗口
共享内存系统监视器大量 IPC 大对象、视频帧

Electron 的「内存占用」通常指所有相关进程的 Working Set / 常驻内存之和。任务管理器里看到的每个进程都要算进去。

指标采集

应用级进程指标

1// src/main/perf/memory.ts
2import { app } from 'electron';
3
4export type ProcessMemorySample = {
5  type: string;
6  pid: number;
7  workingSetMB: number;
8  peakWorkingSetMB: number;
9  cpuPercent: number;
10};
11
12export function sampleProcessMemory(): ProcessMemorySample[] {
13  return app.getAppMetrics().map((metric) => ({
14    type: metric.type,
15    pid: metric.pid,
16    workingSetMB: Math.round(metric.memory.workingSetSize / 1024),
17    peakWorkingSetMB: Math.round(metric.memory.peakWorkingSetSize / 1024),
18    cpuPercent: Number(metric.cpu.percentCPUUsage.toFixed(1)),
19  }));
20}

workingSetSize 的单位是 KB。type 常见为 Browser、Tab、GPU、Utility,可以按类型聚合出「主进程 / 渲染进程 / GPU / 工具进程」四类。

主进程堆

1export function sampleMainHeap(): Record<string, number> {
2  const usage = process.memoryUsage();
3  const mb = (v: number): number => Math.round((v / 1024 / 1024) * 10) / 10;
4  return {
5    rssMB: mb(usage.rss),
6    heapTotalMB: mb(usage.heapTotal),
7    heapUsedMB: mb(usage.heapUsed),
8    externalMB: mb(usage.external),
9    arrayBuffersMB: mb(usage.arrayBuffers),
10  };
11}

渲染进程内存

1export async function sampleRendererMemory(win: BrowserWindow): Promise<{
2  privateMB: number;
3  residentMB: number;
4}> {
5  const info = await win.webContents.getProcessMemoryInfo();
6  return {
7    privateMB: Math.round(info.private / 1024),
8    residentMB: Math.round(info.residentSet / 1024),
9  };
10}

不同平台返回字段略有差异,使用前先看日志确认。

GPU 信息

1const status = app.getGPUFeatureStatus();
2const info = await app.getGPUInfo('basic');
3console.log(status, info);

GPU 内存没有跨平台统一的精确 API,通常结合系统监视器、chrome://gpu 与 DevTools 的 Layers/Rendering 面板判断。

泄漏排查流程

关键原则:

  1. 先证明是泄漏:执行 GC 后内存仍持续上涨,才算泄漏。
  2. 区分常驻与峰值:缓存预热后的稳定值不是泄漏。
  3. 一次只改一个变量:否则无法归因。

堆快照

渲染进程

DevTools → Memory → Heap snapshot:

  1. 打开页面,等待稳定。
  2. 点击「Collect garbage」。
  3. 记录快照 A。
  4. 执行可疑操作 10–50 次。
  5. 再次 GC,记录快照 B。
  6. 选择 Comparison,按 # Delta 排序。

也可以在主进程主动抓取:

1import path from 'node:path';
2import { app, BrowserWindow } from 'electron';
3
4export async function captureRendererHeap(win: BrowserWindow, name: string): Promise<void> {
5  const file = path.join(app.getPath('temp'), `${name}.heapsnapshot`);
6  await win.webContents.takeHeapSnapshot(file);
7  console.log('heap snapshot saved', file);
8}

主进程

1import v8 from 'node:v8';
2import path from 'node:path';
3import { app } from 'electron';
4
5export function captureMainHeap(name: string): void {
6  const file = path.join(app.getPath('temp'), `${name}.heapsnapshot`);
7  v8.writeHeapSnapshot(file);
8  console.log('main heap snapshot saved', file);
9}

把 .heapsnapshot 拖进 DevTools Memory 面板即可分析。

怎么读快照

重点关注:

列含义
Shallow Size对象自身占用
Retained Size该对象被回收后能释放的总内存
# New / # Deleted / # Delta两次快照间的对象数量变化
Distance到 GC Roots 的距离

常见增长对象:

  • Detached HTMLElement:DOM 已移除但 JS 仍持有引用。
  • EventListener / Closure:监听器未移除,闭包持有大对象。
  • Array / Object:无上限缓存。
  • MessagePort / WebContents:未关闭的通信对象。
  • Buffer / ArrayBuffer:二进制数据未释放。

常见泄漏模式

1. 事件监听未移除

1// 泄漏:窗口关闭后监听器仍持有引用
2app.on('browser-window-focus', () => {
3  win.webContents.send('focus-changed');
4});

修复:

1const onFocus = (): void => {
2  if (!win.isDestroyed()) win.webContents.send('focus-changed');
3};
4
5app.on('browser-window-focus', onFocus);
6
7win.on('closed', () => {
8  app.off('browser-window-focus', onFocus);
9});

2. 窗口/WebContents 引用未清理

1// 全局数组持续 push,closed 后不移除
2const windows: BrowserWindow[] = [];
3windows.push(win);

修复:在 closed 中移除,并在使用前检查 isDestroyed()。

3. 无上限缓存

1// 泄漏:缓存永不清理
2const cache = new Map<string, string>();
3cache.set(key, value);

修复:使用 LRU 或设置容量上限:

1class LruCache<K, V> {
2  private readonly map = new Map<K, V>();
3  constructor(private readonly max: number) {}
4
5  get(key: K): V | undefined {
6    const value = this.map.get(key);
7    if (value !== undefined) {
8      this.map.delete(key);
9      this.map.set(key, value);
10    }
11    return value;
12  }
13
14  set(key: K, value: V): void {
15    if (this.map.has(key)) this.map.delete(key);
16    this.map.set(key, value);
17    if (this.map.size > this.max) {
18      const oldest = this.map.keys().next().value;
19      if (oldest !== undefined) this.map.delete(oldest);
20    }
21  }
22}

4. 定时器与轮询

1// 页面卸载后仍然执行
2setInterval(() => fetchData(), 1000);

修复:

1const timer = setInterval(() => fetchData(), 1000);
2
3window.addEventListener('beforeunload', () => {
4  clearInterval(timer);
5});

5. 闭包持有大对象

1function createHandler(bigData: BigData) {
2  return () => {
3    // 即使只用到一个字段,也保留了整个 bigData
4    console.log(bigData.id);
5  };
6}

修复:只捕获需要的字段,或在处理完成后置空引用。

6.MessagePort 未关闭

1const { port1, port2 } = new MessageChannelMain();
2// 通信结束后没有 close

修复:

1port1.close();
2port2.close();

7. Detached DOM

1let detached: HTMLElement | null = null;
2
3function removePanel(): void {
4  const el = document.getElementById('panel');
5  detached = el; // 持有已移除 DOM
6  el?.remove();
7}

修复:移除后不要保留引用;若需要缓存,缓存数据而不是 DOM。

GC 与卡顿

频繁 GC 的典型信号:

  • 内存曲线呈锯齿状且频繁下跌。
  • DevTools Performance 中出现密集的 Minor GC / Major GC。
  • 主进程或渲染进程出现周期性卡顿。

常见原因:

原因表现优化
大量短生命周期对象Minor GC 频繁复用对象、对象池、减少临时数组
大对象分配Major GC 停顿分块处理、流式解析
字符串不断拼接内存与 GC 压力使用数组 join 或 StringBuilder 思路
JSON.parse 超大字符串峰值内存翻倍流式解析、分页
缓存无上限老生代持续增长LRU + TTL

可以在开发环境暴露 GC 验证:

1npx electron --js-flags="--expose-gc" .
1// 仅开发环境
2(globalThis as { gc?: () => void }).gc?.();

生产环境不要依赖手动 GC。

目标拆解:「内存 < 300MB」

以「单窗口 + 托盘常驻」的桌面应用为例,给出示例预算:

进程常驻预算峰值预算说明
主进程80MB120MBNode 堆 + 业务模块 + 原生库
渲染进程(主窗口)120MB180MB首屏 DOM + 框架运行时
GPU 进程60MB120MB纹理与合成缓存
Utility 进程20MB40MB后台任务
其他20MB30MB网络服务、崩溃处理等
合计300MB490MB峰值按场景单独约束

注意:

  • 「300MB」通常指常驻内存,不是峰值。打开大图、大表格时峰值必然更高。
  • 多窗口应用要按窗口数线性预算。
  • macOS 与 Windows 的内存统计口径不同,不能直接横向比较绝对值。
  • Apple Silicon 与 Intel 的 GPU 内存统计方式不同,需要分平台建基线。

大图与缓存治理

图片

  • 按显示尺寸加载,不要用 4K 原图渲染 200px 缩略图。
  • 使用 WebP/AVIF,减少解码后内存。
  • 列表中的图片离开视口后释放引用。
  • 大图查看器使用分块加载或降采样。
1// 生成缩略图时限制最大边长
2function fitWithin(width: number, height: number, max: number) {
3  const scale = Math.min(1, max / Math.max(width, height));
4  return { width: Math.round(width * scale), height: Math.round(height * scale) };
5}

缓存

缓存建议
内存缓存LRU + 容量上限 + TTL
磁盘缓存设置总大小上限,定期清理
图片缓存区分缩略图与原图,原图按需加载
网络响应使用 HTTP 缓存,不要全部堆在内存

Electron 的 session 缓存可以查询与清理:

1const size = await session.defaultSession.getCacheSize();
2console.log('cache size', size);
3
4await session.defaultSession.clearCache();

防劣化:内存门禁

CI 中可以执行固定的自动化场景:

  1. 启动应用,等待首屏稳定。
  2. 执行脚本化操作(打开列表、滚动、切换页面)20 次。
  3. 每次操作后采样 app.getAppMetrics()。
  4. 对比基线:
    • 常驻内存不得超过基线 10%。
    • 操作前后内存增量不得超过基线增量 20%。
    • 连续操作后内存曲线不得呈单调上升。
1type MemoryGate = {
2  baselineMB: number;
3  tolerance: number;
4};
5
6export function checkMemoryGate(samples: number[], gate: MemoryGate): boolean {
7  const stable = samples.slice(-3);
8  const avg = stable.reduce((a, b) => a + b, 0) / stable.length;
9  return avg <= gate.baselineMB * (1 + gate.tolerance);
10}

门禁失败时输出每个进程的明细,便于定位是主进程、渲染进程还是 GPU 增长。

本章小结

  • Electron 内存由多个进程组成,必须分进程观察与预算。
  • 泄漏排查的核心是「GC 后仍上涨」与「快照对比」,不是看单次数值。
  • 最常见泄漏来自事件监听、全局引用、无上限缓存、定时器与 Detached DOM。
  • 频繁 GC 往往由大量短生命周期对象或大对象分配引起,优化方向是复用与分块。
  • 「< 300MB」要拆成常驻/峰值、分进程预算,并用自动化门禁防止劣化。

参考资料