《Electron 45.2.3 内核解剖》第 2 章 进程模型:四个进程与一条命令线
本章目标:把第 1 章那张"进程地图"填满。 读完你应该能回答:Electron 启动一个窗口时到底 fork 了几次?
--type=renderer这个字符串在哪一行被消费?为什么 Linux 多一个 zygote 进程?utility process 和child_process.fork()有什么区别?渲染进程崩溃之后发生了什么?
2.1 一条命令行决定进程身份
第 1 章做过一个观察:ps -ef 里所有 Electron 子进程都长一个样,区别只在命令行参数。这一节把这个观察坐实到代码。
2.1.1 判定的实现只有 30 行
process_util.cc:18-25 全文不到 50 行,但它是整个进程模型的判定中心:
process_util.cc:18-47
std::string GetProcessType() {
auto* command_line = base::CommandLine::ForCurrentProcess();
return command_line->GetSwitchValueASCII(switches::kProcessType);
}
bool IsBrowserProcess() {
static bool result = GetProcessType().empty();
return result;
}
bool IsRendererProcess() {
static bool result = GetProcessType() == switches::kRendererProcess;
return result;
}
bool IsUtilityProcess() {
static bool result = GetProcessType() == switches::kUtilityProcess;
return result;
}
bool IsZygoteProcess() {
static bool result = GetProcessType() == switches::kZygoteProcess;
return result;
}
bool IsRunningAsNode() {
static bool result = fuses::IsRunAsNodeEnabled() &&
base::Environment::Create()->HasVar(kRunAsNode);
return result;
}
四个 static bool,四个函数。这里有三处值得停下来想。
第一处:static 的含义。
每个函数里的 static bool result = ... 意味着这个判断在进程生命周期内只计算一次,之后直接返回缓存值。
为什么可以这样?因为进程类型在进程启动后不会变。一个进程要么是渲染进程,要么不是,中途不可能"变成"主进程。
这个设计带来一个有意思的后果:如果你在运行时修改命令行(app.commandLine.appendSwitch('type', 'renderer')),IsRendererProcess() 不会跟着变。 缓存已经固化了。
这不是 bug,是刻意优化——这几个函数在热路径上被调用(每次创建窗口、每次 IPC 都要判类型),加锁或重复解析命令行都是浪费。
第二处:IsBrowserProcess() 判的是"类型为空"。
注意它不是判 == "browser",而是判 .empty()。
为什么?因为主进程启动时,Chromium 根本不会给它加 --type。--type 这个开关的语义是"我是一个子进程,我的类型是 X",主进程不需要声明自己。
这是一个来自 Chromium 的约定。它的后果是:任何没有 --type 的进程都会被判定为 browser process。
而这个后果,直接引出了第三处。
第三处:IsRunningAsNode() 存在的理由。
ELECTRON_RUN_AS_NODE=1 模式下,Electron 二进制被当作纯 Node 使用:
ELECTRON_RUN_AS_NODE=1 ./electron -e "console.log(process.versions.node)"
这个进程没有 --type,所以 IsBrowserProcess() 返回 true。但它显然不是主进程——它没有 app 对象,没有窗口能力,只有一个裸的 Node 环境。
所以必须有第二个判断:
process_util.cc:43-46
bool IsRunningAsNode() {
static bool result = fuses::IsRunAsNodeEnabled() &&
base::Environment::Create()->HasVar(kRunAsNode);
return result;
}
两个条件:
- fuse 允许(
IsRunAsNodeEnabled)——打包时可以关掉这个能力,防止攻击者把你的应用当 Node 解释器用; - 环境变量存在。
这个函数的注释值得再贴一次,因为它是全仓库最好的"踩坑记录"之一:
// True when this process is the ELECTRON_RUN_AS_NODE entry point (e.g. a
// child_process.fork()ed Node process). Such a process has no --type switch,
// so IsBrowserProcess() is also true for it; use this to tell the two apart.
"use this to tell the two apart"——如果你在写 Electron 内部代码时忘了这一点,就会遇到"fork 出来的 Node 子进程莫名其妙地尝试初始化窗口系统"这类诡异崩溃。
2.1.2 --type 的值从哪里来
switches::kProcessType 定义在 Chromium 的 content/public/common/content_switches.h。它的字符串值是 "type"。
Chromium 定义了一组标准值:
--type=renderer
--type=gpu-process
--type=utility
--type=zygote
--type=ppapi (已被废弃)
--type=service (服务进程,比如网络服务)
注意 gpu-process 带连字符、utility 和 zygote 不带——这是 Chromium 内部历史遗留的不一致,Electron 只是照单全收。
Electron 在这些之外还加了自己的:
--type=app-shim (macOS 的 app shim 进程)
shell/app_shim/ 目录对应这个类型。它只在 macOS 上存在,负责处理 Dock 菜单、协议注册这类"应用外壳"的事情。
2.1.3 判定之后发生什么
知道了自己是谁,进程就走对应的初始化路径。分叉点在 ElectronMainDelegate:
// 伪代码,表达逻辑
content::ContentBrowserClient* ElectronMainDelegate::CreateContentBrowserClient() {
return new ElectronBrowserClient();
}
content::ContentRendererClient* ElectronMainDelegate::CreateContentRendererClient() {
if (IsSandboxedProcess()) {
return new ElectronSandboxedRendererClient();
}
return new ElectronRendererClient();
}
content::ContentUtilityClient* ElectronMainDelegate::CreateContentUtilityClient() {
return new ElectronContentUtilityClient();
}
三个 Client,三种世界。渲染进程还分两个版本——沙箱和非沙箱。这一点在第 12 章展开,这里先记住:沙箱进程里没有 Node,所以需要一套完全不同的脚本加载逻辑。
2.1.4 一个实用推论:如何判断自己在哪个进程
从上面的代码可以推出一个精确的判断方法:
const isMainProcess = process.type === 'browser' && !process.env.ELECTRON_RUN_AS_NODE
const isRenderer = process.type === 'renderer'
const isUtility = process.type === 'utility'
const isWorker = process.type === 'worker' // Web Worker / Service Worker
最后一项是个容易忽略的点:Worker 里的 process.type 是 "worker",不是 "renderer"。
但更可靠的方式是用 Electron 提供的显式 API:
// 主进程
const { app } = require('electron')
// 渲染进程
const { ipcRenderer } = require('electron')
因为**"有哪些模块可用"本身就是最准确的进程标识**。app 存在即主进程,ipcRenderer 存在即渲染进程。比字符串比较可靠得多。
2.2 为什么必须是多进程
理解了"怎么判定",下一个问题是"为什么要分"。这不是 Electron 的选择,是浏览器的必然。
2.2.1 单进程浏览器的死法
2006 年之前的浏览器基本都是单进程。它们死于三件事:
第一,一个页面卡死,整个浏览器卡死。
页面里的 while(true){} 会占满唯一的 JS 线程,浏览器的 UI 也在这条线程上,于是菜单点不动、窗口拖不动、连"关闭"按钮都不响应。
第二,一个页面崩溃,整个浏览器崩溃。
页面里的一次野指针(那年代的插件、Flash、图形驱动)会让整个进程 segfault,所有标签页一起消失。
第三,一个页面能读另一个页面的数据。
单进程意味着共享地址空间。A 网站的脚本可以(通过漏洞或设计缺陷)读到 B 网站的 DOM、cookie、密码。这在同源策略只有"逻辑隔离"的年代是灾难。
Chrome 的答案是:把每个标签页放进独立进程,用操作系统提供的进程边界作为隔离手段。
操作系统保证进程之间不能互相读写内存,这是硬件 MMU 提供的能力,比任何软件沙箱都硬。
2.2.2 代价与权衡
多进程不是免费的:
| 成本 | 量级 |
|---|---|
| 每个进程的地址空间 | 数十 MB 起 |
| 进程创建时间 | 10-50 ms(Linux fork 更快,Windows 更慢) |
| 进程间通信 | 必须序列化,不能共享指针 |
| 内存无法共享 | 同一个 JS 引擎的代码段要复制多份(部分可由 OS 共享) |
Electron 的实际数字:一个空窗口约占用 3 个进程(主 + 渲染 + GPU),内存 150-250 MB 起。每多一个窗口,多约 40-80 MB。
这就是为什么 Electron 应用"内存大"——它用内存买隔离性和稳定性。
2.2.3 Chromium 的进程模型细节
Chromium 的进程模型比"一个标签一个进程"复杂得多,因为它要处理很多边界情况。核心概念是 SiteInstance:
- 一个
SiteInstance代表"一组同站点的页面"; - 同站点的页面可以共享一个渲染进程;
- 跨站点的导航会触发进程交换(process swap)。
Electron 在这套机制上有自己的策略,写在 ElectronBrowserClient 里:
electron_browser_client.cc:931-960
bool ElectronBrowserClient::IsSuitableHost(
content::RenderProcessHost* process_host,
const content::SecurityPrincipal& security_principal) {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
auto* browser_context = process_host->GetBrowserContext();
extensions::ProcessMap* process_map = extensions::ProcessMap::Get(browser_context);
const auto privilege_required =
GetPrivilegeRequiredBySecurityPrincipal(security_principal);
return GetProcessPrivilege(process_host, process_map) == privilege_required;
#else
return content::ContentBrowserClient::IsSuitableHost(process_host,
security_principal);
#endif
}
bool ElectronBrowserClient::ShouldUseProcessPerSite(
content::BrowserContext* browser_context,
const content::SecurityPrincipal& security_principal) {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
const extensions::Extension* extension =
GetEnabledExtensionFromSecurityPrincipal(browser_context, security_principal);
return extension != nullptr;
#else
return content::ContentBrowserClient::ShouldUseProcessPerSite(
browser_context, security_principal);
#endif
}
注意 #else 分支:什么都不改,直接用 Chromium 的默认策略。
这是一个非常重要的事实:Electron 默认没有开启严格的站点隔离,它用的是 Chromium 的默认行为。
而 Chromium 的默认行为在桌面端是"部分隔离"——同站点的多个 frame 共享进程,跨站点 iframe 可能共享也可能不共享,取决于平台和 feature flag。
这解释了一个常见的困惑:为什么两个不同域名的窗口可能跑在同一个渲染进程里?
因为 Electron 没有强制"每站点一进程"。如果你需要强隔离,可以在创建窗口时用不同的 partition(不同 session 必然不同进程),或者在 webPreferences 里设置 sandbox + 注意导航时的进程交换策略。
第 15 章讲安全时会回到这个话题,并给出一个可以验证的判定表。
2.2.4 Electron 的一个特殊点:窗口 = 进程
在浏览器里,"标签页"和"进程"的映射是动态的:一个标签页导航到新站点可能换进程,多个标签页可能共享进程。
Electron 里,"窗口"和"进程"的关系更直接:每个 BrowserWindow 默认创建自己的 WebContents,而每个 WebContents 通常对应一个渲染进程。
但这个"通常"有很多例外:
- 同一个窗口里导航到同站点的新页面:不换进程;
window.open()打开的子窗口:默认可能共享 opener 的进程(如果同站点);webview标签:默认独立进程(guest 必须隔离);- iframe:默认跟随父页面,除非跨站点且触发隔离。
如果你在调试"为什么我的全局变量丢了",答案往往是"进程换了"。 第 11 章会给出检测方法。
2.3 主进程解剖:一条进程,五条线程
主进程不是一个"单线程的东西"。它至少包含五条有名字的线程,各自负责不同的事。
2.3.1 UI 线程(主线程)
这是你写 main.js 时所在的那条线程。它负责:
- 执行所有主进程的 JS;
- 创建/销毁原生窗口(Windows 的
HWND、macOS 的NSWindow、Linux 的 X11 window); - 处理 UI 事件(菜单点击、托盘点击、窗口 resize);
- 驱动 Chromium 的 message loop;
- 驱动 Node 的事件循环(通过
UvRunOnce,见第 6 章); - 分发 IPC 消息到 JS 监听器。
这条线程被阻塞,整个应用就"卡死"(窗口不再重绘、菜单无响应、IPC 延迟)。这是 Electron 应用最常见的性能问题来源。
所以有一个硬性建议:不要在 UI 线程做 CPU 密集计算。如果你必须做,用 utilityProcess.fork() 或 worker_threads。
2.3.2 IO 线程
Chromium 的 BrowserThread::IO。它负责:
- 处理来自渲染进程的 IPC 消息(原始字节的收发);
- 网络请求的调度;
- 文件描述符的传递;
- mojo 消息的序列化/反序列化(部分)。
IO 线程的名字有点误导——它不只是"做 IO",它是"所有跨进程消息的第一站"。消息在 IO 线程被解析成 mojo 消息,然后 PostTask 到 UI 线程执行实际逻辑。
这意味着 IPC 有两次线程切换:IO 线程收 → 投递到 UI 线程处理 → 如果需要回复,再从 UI 线程投递到 IO 线程发出。
这就是为什么 ipcRenderer.invoke() 的往返时间通常是 0.1-1 ms 量级,而不是微秒级。
2.3.3 EmbedThread(Node 的 libuv 线程)
这是 Electron 特有的线程。它的存在理由在 node_bindings.h 的注释里:
// A helper class to manage uv_handle_t types, e.g. uv_async_t.
//
// As per the uv docs: "uv_close() MUST be called on each handle before
// memory is released. Moreover, the memory can only be released in
// close_cb or after it has returned."
这个类管的是 uv handle 的生命周期,但它引出的问题是:为什么需要一条单独的线程跑 uv loop?
因为 Node 的 libuv 有自己的事件循环(uv_loop_t),Chromium 有自己的 message loop。两者不能"合并",只能"协作"。
协作方式是:
主线程(Chromium message loop)
│
├─ 每轮迭代调用 UvRunOnce()
│ └─▶ uv_run(loop, UV_RUN_NOWAIT) ← 非阻塞地推进一次
│
└─ Node 侧有异步事件时
└─▶ EmbedThread 检测到 → WakeupMainThread() → 主线程下一轮处理
EmbedThreadRunner 的循环:
node_bindings.cc:1192-1199
// shell/common/node_bindings.cc:1192-1213(结构)
void NodeBindings::EmbedThreadRunner(void* arg) {
auto* self = static_cast<NodeBindings*>(arg);
while (true) {
int idle = uv_run(self->uv_loop(), UV_RUN_ONCE);
if (idle == 0) {
self->WakeupMainThread();
} else {
self->WakeupEmbedThread(); // uv_sem_wait
}
if (self->embed_closed_) break;
}
}
uv_run(loop, UV_RUN_ONCE) 会阻塞直到有事件或超时。有事件就唤醒主线程,没事件就 uv_sem_wait 睡死。
这条线程的存在,是"两个事件循环共存"这个根本问题的工程答案。 第 6 章会完整拆解,包括它带来的时序差异(setImmediate 在主进程里的行为与纯 Node 不同)。
2.3.4 线程池(base::ThreadPool)
Chromium 的通用线程池,默认大小与 CPU 核心数相关。它跑:
- 文件 IO(
base::FileProxy); - DNS 解析;
- 压缩/解压;
- 一些
PostTask到ThreadPool的后台任务。
Electron 的很多同步 API 在内部会投递到线程池然后用 WaitableEvent 等结果——比如 fs.readFileSync 在某些路径上。
这意味着"同步 API 阻塞 UI 线程"的后果比看起来严重:如果线程池被打满,同步调用会等待更久。
2.3.5 其他专用线程
按需创建:
| 线程 | 用途 |
|---|---|
Chrome_DevTools | DevTools 的协议处理 |
NetworkService | 网络服务(可能是独立进程,也可能是线程) |
CrashpadHandler | 崩溃处理(独立进程) |
AudioThread | 音频渲染 |
2.3.6 主进程的内存构成
理解了线程,就能理解为什么主进程内存不小:
主进程内存
├─ V8 Isolate(含 Node 的内置模块、你的 main.js)
├─ Chromium 的 content 层对象(BrowserContext、WebContents 的宿主部分)
├─ 每个窗口的原生资源(位图、GL 上下文句柄)
├─ 网络栈(socket 缓冲、证书缓存)
└─ Node 的 libuv 与线程池栈
一个只开一个窗口的 Electron 应用,主进程通常占 80-150 MB。
2.4 渲染进程:从 new BrowserWindow 到 --type=renderer
这是本章最核心的一节。我们把"渲染进程是怎么被创建出来的"完整走一遍。
2.4.1 触发点
渲染进程不是在 new BrowserWindow() 时立刻创建的,而是在第一次导航时。
原因:WebContents 创建时只是构造了一个"逻辑对象",它还不知道要加载什么。等到 loadURL() 被调用,NavigationController 需要决定"用哪个进程来渲染这个 URL",这时才会请求 RenderProcessHost。
这个延迟很重要:它让"创建了窗口但没加载页面"的场景不必浪费一个进程。
2.4.2 RenderProcessHost 的创建流程
NavigationControllerImpl::LoadURL()
└─▶ NavigationRequest 创建
└─▶ 计算 SiteInstance
└─▶ SiteInstanceImpl::GetProcess()
└─▶ RenderProcessHostImpl 创建(如果复用不了)
├─▶ ElectronBrowserClient::RenderProcessWillLaunch(host)
├─▶ ChildProcessLauncher::Launch()
│ ├─▶ ElectronBrowserClient::AppendExtraCommandLineSwitches()
│ ├─▶ 决定 sandbox 开关
│ └─▶ fork / spawn
└─▶ 建立 mojo 通道
2.4.3 RenderProcessWillLaunch:Electron 的第一个钩子
electron_browser_client.cc:489-495
void ElectronBrowserClient::RenderProcessWillLaunch(
content::RenderProcessHost* host) {
// Remove in case the host is reused after a crash, otherwise noop.
host->RemoveObserver(this);
// ensure the ProcessPreferences is removed later
host->AddObserver(this);
}
只有两行,但注释说明了它的用途:注册观察者,以便在进程销毁时清理。
RemoveObserver 那行很关键:如果 host 是崩溃后复用的,它可能已经注册过了。 先移再加,保证不会重复。
这是一个防御性写法,也是一个信号:渲染进程会崩溃,host 会被复用。 这是常态,不是异常。
2.4.4 AppendExtraCommandLineSwitches:命令行的最后一道加工
这是子进程启动前最后一次修改命令行的机会。函数有 140 行左右,做的第一件事不是加参数,而是校验:
electron_browser_client.cc:583-590
// shell/browser/electron_browser_client.cc:583-630(节选)
void ElectronBrowserClient::AppendExtraCommandLineSwitches(
base::CommandLine* command_line,
int process_id) {
// Make sure we're about to launch a known executable
#if BUILDFLAG(IS_LINUX)
if (command_line->GetProgram() != base::FilePath(base::kProcSelfExe)) {
#else
{
#endif
ScopedAllowBlockingForElectron allow_blocking;
base::FilePath child_path;
base::FilePath program =
base::MakeAbsoluteFilePath(command_line->GetProgram());
...
CHECK_EQ(program, child_path)
<< "Aborted from launching unexpected helper executable";
}
这段代码在防一类具体的攻击。
场景:如果攻击者能控制 command_line->GetProgram()(比如通过环境变量、配置文件注入),就能让 Electron 启动任意可执行文件——而且是以应用的身份、带着应用的签名。
CHECK_EQ 在 release 构建里依然生效(不是 DCHECK),因为这是安全关键路径。Linux 上还特意放过 /proc/self/exe,注释解释了原因:它永远指向当前可执行文件,无需检查,而且如果文件被删除会返回一个假名字导致误判。
校验之后才是真正的工作:追加开关。
虽然我没法在这里列出全部 140 行,但可以给出结构:它会把主进程的 command_line 里一批"需要传递给子进程"的开关复制过去,包括:
--lang(语言)--user-data-dir- crashpad 相关
- Electron 自己的开关(
--app-path之类)
"哪些开关要传,哪些不传"是一份需要仔细维护的白名单。 传多了会泄漏主进程的配置,传少了子进程行为不对。
2.4.5 沙箱决策
渲染进程是否启用沙箱,由几个因素共同决定:
webPreferences.sandbox的值;nodeIntegration的值(true 时不能开沙箱);- 命令行是否有
--no-sandbox; - macOS 上的 entitlements;
- fuse 配置。
判定结果最终体现为子进程命令行里的 --enable-sandbox 或 --no-sandbox。
而"这个进程到底开没开沙箱"这个问题,Electron 提供了查询接口:
electron_browser_client.cc:481-488
std::optional<bool> ElectronBrowserClient::IsRendererProcessSandboxed(
content::ChildProcessId process_id) const {
...
}
头文件里的注释很谨慎:
// Whether the given renderer process was launched with the OS sandbox
// enabled. Returns nullopt if the launch state of the process is unknown.
返回 nullopt 而不是 false——因为"未知"和"确定没开"是两件事。API 设计上区分这两种状态,说明作者踩过"把未知当 false"的坑。
2.4.6 webPreferences 怎么传给渲染进程
命令行只能传字符串,而 webPreferences 是一个复杂的对象。它怎么过去?
答案:不走命令行,走 mojo。
WebContentsPreferences 这个类(web_contents_preferences.h)负责在 browser 侧序列化,然后通过一个 mojo 关联接口在渲染进程启动后推送过去。
渲染进程侧收到后,存到一个全局表里,webFrame.getWebPreference() 就是查这张表。
这就是为什么:
webPreferences可以在运行时改(webContents.setWindowOpenHandler里改的选项会生效);- 但某些选项只在进程创建时生效(比如
sandbox),后改无效。
"哪些选项是创建时决定的、哪些可以热改"这个问题的答案,在 WebContentsPreferences 的实现里。 第 11 章会列表。
2.4.7 一个完整的时序
[t=0ms] JS: win.loadURL('https://example.com')
│
[t=0ms] C++: WebContents::LoadURL()
│
[t=1ms] NavigationRequest 创建,计算 SiteInstance
│
[t=2ms] 没有可复用的 RenderProcessHost → 创建新的
│
[t=2ms] RenderProcessWillLaunch(host) ← Electron 钩子 1
│
[t=3ms] ChildProcessLauncher::Launch()
├─ 组装命令行(--type=renderer --enable-sandbox ...)
├─ AppendExtraCommandLineSwitches() ← Electron 钩子 2
└─ fork()
│
[t=15ms] 子进程启动
├─ ContentMain → 走 renderer 路径
├─ 初始化 Blink、创建 RenderThread
└─ 建立 mojo 连接
│
[t=25ms] browser 侧收到"进程就绪"
├─ 推送 webPreferences
└─ 创建 RenderFrameHost
│
[t=30ms] 导航提交,开始加载资源
这个 30ms 是"冷启动一个窗口"的典型值。 如果进程池里有可复用的,可以降到 10ms 以内。
Electron 支持"预热渲染进程"(spare_renderer_compatible),就是为了减少这个延迟。头文件里能看到它的痕迹:
electron_browser_client.h:86
bool* spare_renderer_compatible() { return &spare_renderer_compatible_; }
2.5 GPU 进程:你看不见的那个
Electron 应用启动时,通常会有第三个进程:--type=gpu-process。
2.5.1 它做什么
GPU 进程负责:
- 合成(compositing):把多个图层(页面内容、滚动条、视频、窗口背景)合成为一帧;
- 光栅化(rasterization):把矢量绘制指令转成位图;
- GPU 加速:调用 OpenGL / Direct3D / Vulkan / Metal 执行绘制;
- 视频解码:把 H.264/H.265 码流转成纹理;
- WebGL / WebGPU 执行:真正的 GPU 命令在这里执行。
渲染进程只负责"生成绘制指令"(cc::DisplayItemList),实际的像素计算在 GPU 进程。
2.5.2 为什么 GPU 也要独立进程
三个理由:
第一,驱动不稳定。 显卡驱动是内核态 + 用户态的混合体,历史上充满内存越界与死锁。把驱动跑在独立进程里,驱动崩了只崩 GPU 进程,浏览器主进程可以重建它并回退到软件渲染。
第二,权限隔离。 GPU 进程需要访问 /dev/dri/*(Linux)或 GPU 设备句柄,这些权限不该给渲染进程。
第三,沙箱分层。 渲染进程的沙箱最严格(不能访问 GPU 设备),GPU 进程次之,主进程最宽松。
2.5.3 Electron 在这里做了什么
Electron 对 GPU 进程的介入极少:
electron_gpu_client.h:13-25
class ElectronGpuClient : public content::ContentGpuClient {
public:
ElectronGpuClient();
ElectronGpuClient(const ElectronGpuClient&) = delete;
ElectronGpuClient& operator=(const ElectronGpuClient&) = delete;
// content::ContentGpuClient:
void PreCreateMessageLoop() override;
};
只有一个虚函数被重写。这说明 GPU 进程对 Electron 来说几乎是"透明"的——它跑的是 Chromium 的原生逻辑。
但有一件事 Electron 必须处理:离屏渲染(OSR)。shell/browser/osr/ 目录下有一套完整的替代实现:
shell/browser/osr/
├── osr_render_widget_host_view.cc 替代真正的 RenderWidgetHostView
├── osr_web_contents_view.cc 替代 WebContentsView
├── osr_host_display_client.cc 把合成结果交给宿主
├── osr_paint_event.cc 把帧转成位图
└── osr_video_consumer.cc 直接消费视频帧
离屏渲染的意义在 webPreferences.offscreen:渲染结果不显示在窗口上,而是通过 paint 事件交给你。 这让 Electron 能用于:
- 服务端截图(无显示器环境);
- 视频录制;
- 自定义渲染管线(把画面喂给三个.js、Unity 之类);
- 虚拟显示器。
OSR 的代价是:你放弃了 GPU 合成的大部分优势,每帧都要从 GPU 内存读回 CPU 内存(readback),性能显著下降。第 13 章会详细拆解。
2.5.4 GPU 进程崩溃之后
如果一个 Electron 应用"白屏但没崩",很可能 GPU 进程崩了。
诊断方法:
app.on('child-process-gone', (event, details) => {
console.log(details.type, details.reason, details.exitCode)
})
details.type 为 'GPU' 时就是它。
恢复策略:Chromium 会自动重启 GPU 进程,并可能回退到软件渲染(SwiftShader)。你可以主动干预:
// 强制禁用 GPU 加速(排查用)
app.disableHardwareAcceleration()
注意这行必须在 app.ready 之前调用,因为它要修改命令行。
2.6 utility process:Electron 的"第三类公民"
utilityProcess.fork() 是 Electron 22 引入的 API,但它的底层机制来自 Chromium 更早就有的 ServiceProcessHost。
2.6.1 它解决什么问题
在 utilityProcess 之前,开发者做 CPU 密集计算有两个选择:
child_process.fork():fork 一个 Node 进程。问题是这个进程不受 Chromium 管理,没有沙箱、没有MessagePort、不能访问session、崩溃了不会触发child-process-gone。worker_threads:线程,不是进程。共享地址空间,一个 segfault 全崩;而且 V8 的线程隔离不如进程隔离彻底。
utilityProcess 填了中间的空:一个被 Chromium 管理的、有完整 Node 环境的子进程。
它的能力边界:
| 能力 | utilityProcess | child_process | worker_threads |
|---|---|---|---|
| 独立进程 | ✅ | ✅ | ❌ |
| 完整 Node 环境 | ✅ | ✅ | ✅(受限) |
| 可被主进程监控 | ✅ | 部分 | ❌ |
| MessagePort | ✅ | ❌(需自己实现) | ✅ |
| 访问 session/网络 | ✅(通过注入的 URLLoaderFactory) | 自己建 | ❌ |
| 沙箱 | ❌(见下文) | ❌ | — |
| 崩溃不拖累主进程 | ✅ | ✅ | ❌ |
2.6.2 创建流程的源码
UtilityProcessWrapper::Create 是入口:
electron_api_utility_process.cc:614-628
UtilityProcessWrapper* UtilityProcessWrapper::Create(
gin::Arguments* const args) {
if (!Browser::Get()->is_ready()) {
args->ThrowTypeError(
"utilityProcess cannot be created before app is ready.");
return nullptr;
}
gin_helper::Dictionary dict;
if (!args->GetNext(&dict)) {
args->ThrowTypeError("Options must be an object.");
return nullptr;
}
第一行就是一条硬约束:必须在 app.ready 之后。
为什么?因为 utility process 的启动依赖 BrowserProcessImpl(假的 g_browser_process)和网络上下文,这些东西在 ready 之后才齐全。
接着读参数:
electron_api_utility_process.cc:628-635
std::u16string display_name;
bool use_plugin_helper = false;
bool create_network_observer = false;
bool disclaim_responsibility = false;
api::Session* session = nullptr;
std::map<IOHandle, IOType> stdio;
base::FilePath current_working_directory;
base::EnvironmentMap env_map;
node::mojom::NodeServiceParamsPtr params =
node::mojom::NodeServiceParams::New();
dict.Get("modulePath", ¶ms->script);
NodeServiceParams 是跨进程传递的参数结构,定义在 node_service.mojom:22-27:
struct NodeServiceParams {
mojo_base.mojom.FilePath script;
array<string> args;
array<string> exec_args;
blink.mojom.MessagePortDescriptor port;
URLLoaderFactoryParams url_loader_factory_params;
};
五个字段,五件事:
script:入口脚本路径;args:传给脚本的参数(process.argv);exec_args:Node 自己的参数(--inspect之类);port:一个MessagePort,用于双向通信;url_loader_factory_params:网络能力。
最后一项最值得注意:utility process 没有自己的网络栈,它借用主进程的 URLLoaderFactory。
这是通过 mojo 传过去的:
UtilityProcessWrapper::CreateURLLoaderFactoryParams()
在 node_service.mojom 里,URLLoaderFactoryParams 包含一个 pending_remote<network.mojom.URLLoaderFactory> 和一个 pending_remote<network.mojom.HostResolver>。
也就是说:utility process 里调 fetch(),请求会通过 mojo 回到主进程的网络服务,走的是同一个 session、同一套 cookie、同一个代理配置。
这就是"用 session.fromPartition() 指定分区"在 utility process 里也能生效的原因。
2.6.3 stdio 的处理
stdio 选项是个三元组(stdin/stdout/stderr),每个可以是 "ignore" / "inherit" / "pipe"。
默认值在代码里写得很清楚:
electron_api_utility_process.cc:660-663
constexpr std::array default_stdio{
IOType::IO_IGNORE,
IOType::IO_INHERIT,
IOType::IO_INHERIT,
};
stdin 默认 ignore,stdout/stderr 默认 inherit。
这意味着:默认情况下,utility process 的 console.log 会直接输出到父进程的终端——这正是你调试时想要的行为。如果你想捕获它,设成 "pipe":
const child = utilityProcess.fork(path.join(__dirname, 'worker.js'), [], {
stdio: 'pipe'
})
child.stdout.on('data', (data) => console.log('[worker]', data.toString()))
实现上,Windows 用 CreatePipe + SetHandleInformation,POSIX 用 pipe() + fd 重映射。代码里对两个平台的处理几乎是对称的:
electron_api_utility_process.cc:148-152
#if BUILDFLAG(IS_WIN)
HANDLE read = nullptr;
HANDLE write = nullptr;
if (!::CreatePipe(&read, &write, nullptr, 0)) { ... }
...
#elif BUILDFLAG(IS_POSIX)
int pipe_fd[2];
if (HANDLE_EINTR(pipe(pipe_fd)) < 0) { ... }
HANDLE_EINTR 那个宏很关键:pipe() 可能被信号中断返回 EINTR,必须重试。这是 POSIX 编程的基本功,Chromium 用宏把它封装了。
2.6.4 启动:交给 Chromium 的服务进程框架
真正的进程创建不是 Electron 做的,是 Chromium:
electron_api_utility_process.cc:229-236
content::ServiceProcessHost::Launch(
std::move(receiver),
content::ServiceProcessHost::Options()
.WithDisplayName(display_name.empty()
? std::u16string(u"Node Utility Process")
: display_name)
.WithExtraCommandLineSwitches(params->exec_args)
.WithCurrentDirectory(current_working_directory)
.WithEnvironment(env_map,
env_map.empty() ? false : true /*clear_environment*/)
#if BUILDFLAG(IS_WIN)
.WithStdoutHandle(std::move(stdout_write))
.WithStderrHandle(std::move(stderr_write))
.WithFeedbackCursorOff(true)
#elif BUILDFLAG(IS_POSIX)
.WithAdditionalFds(std::move(fds_to_remap))
#endif
.WithProcessCallback(...)
.Pass());
这是一个典型的 Fluent API,每个 .With* 都在设置一个 base::LaunchOptions 的字段。
三个细节值得看:
WithEnvironment(env_map, env_map.empty() ? false : true)
第二个参数是 clear_environment。逻辑是:如果用户给了环境变量,就清空继承的环境再加用户给的;如果没给,就完全继承。
这个语义很微妙:给了 env 意味着"我要完全控制环境",所以连 PATH 都不继承(除非你自己给)。这是一个容易踩的坑——传了 { MY_VAR: '1' } 之后,子进程里 PATH 就没了。
WithFeedbackCursorOff(true)(仅 Windows)
关掉"反馈光标"(那个显示忙碌的转圈)。因为 utility process 是后台进程,不应该影响光标。
macOS 的 WithDisclaimResponsibility
这是一个 macOS 特有的能力:进程可以声明"我不代表父应用",从而避免在 Dock 里显示图标、避免继承父进程的某些属性。对应 disclaim 选项。
2.6.5 沙箱:为什么 utility process 不能开
看 mojom 定义里的那一行注解:
node_service.mojom:41-42
[ServiceSandbox=sandbox.mojom.Sandbox.kNoSandbox]
interface NodeService {
kNoSandbox——这个 NodeService 接口明确声明"我不要沙箱"。
原因很直接:Node 需要访问文件系统、需要 dlopen 原生模块、需要创建 socket、需要 fork。这些在严格沙箱下全部被禁止。
对比一下 Chromium 自己的网络服务:
[ServiceSandbox=sandbox.mojom.Sandbox.kNetwork]
网络服务有专门的 kNetwork 沙箱策略,只放行网络相关能力。
这就是 utility process 的安全定位:它不是沙箱,它是"隔离但不受限"。 如果你的应用要加载不可信代码,不要用 utility process——用渲染进程 + 沙箱。
2.6.6 NodeService:utility 进程里的 Node
渲染进程里的 Node 是"把 Node 环境嵌入 Blink 的进程",utility 进程里的 Node 是"一个 Node 服务"。
NodeService 接口只有三个方法:
node_service.mojom:42-48
interface NodeService {
Initialize(NodeServiceParams params,
pending_remote<NodeServiceClient> client_remote);
UpdateURLLoaderFactory(URLLoaderFactoryParams params);
[EnableIf=enable_prompt_api]
BindAIManager(BindAIManagerParams params,
pending_receiver<blink.mojom.AIManager> ai_manager);
};
Initialize 是主入口。它收到的参数里带着脚本路径、参数、MessagePort、网络工厂。
UpdateURLLoaderFactory 是热更新:当主进程的网络服务崩溃重建时,主进程会重新推一份工厂给 utility 进程。这就是为什么代码里要订阅 network_service_gone:
electron_api_utility_process.cc:287-289
network_service_gone_subscription_ =
content::RegisterNetworkServiceProcessGoneHandler(base::BindRepeating(
&UtilityProcessWrapper::CreateAndSendURLLoaderFactory, ...));
这个设计说明了一个事实:mojo 接口是会断的,必须处理重连。
BindAIManager 是最近加的(enable_prompt_api),用于把浏览器的 AI 能力暴露给 utility 进程。这是 Electron 45 的新东西,第 24 章会提到。
NodeServiceClient 只有一个方法 OnV8FatalError,让子进程在 V8 致命错误时通知父进程:
node_service.mojom:37-38
interface NodeServiceClient {
OnV8FatalError(string location, string report);
};
有了它,utility 进程的 V8 崩溃能被主进程感知并转成 exit 事件,而不是无声消失。
2.6.7 生命周期与清理
UtilityProcessWrapper 的构造里有一段注释,说明了注册时机的重要性:
electron_api_utility_process.cc:118
// Registered before anything can fail, so that browser shutdown also reaches
// a wrapper whose child is still launching. HandleTermination() removes it.
GetAllUtilityProcessWrappers().Add(this);
先注册,再做任何可能失败的事。 这样即使启动失败,关闭流程也能找到这个 wrapper 并清理。
而失败路径也不是直接抛异常,而是投递一个任务:
electron_api_utility_process.cc:129-132
auto fail_launch = [&] {
...
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE,
base::BindOnce(&UtilityProcessWrapper::HandleTermination, ..., kLaunchFailureExitCode));
};
注释解释了原因:
// Nothing else calls HandleTermination() if we bail before launch; post it
// so 'exit' fires after JS has attached its listeners.
post 而不是直接调用,是为了让 JS 有机会先 on('exit')。 如果同步发事件,调用方还没来得及注册监听器,事件就丢了。
这是一个在异步 API 设计里反复出现的模式:"失败也要异步通知",否则用户拿不到错误。
2.6.8 关闭:ShutdownAll
第 1 章引用过的关闭流程里有一行:
electron_browser_main_parts.cc:746
api::UtilityProcessWrapper::ShutdownAll();
它的注释解释了这个顺序的必要性:必须在 node::Stop 之前,否则 exit 事件发不出去。
而 ShutdownAll 内部会遍历所有 wrapper,包括"还在启动中"的那些:
// 注释原文
// This includes wrappers whose child is still launching; otherwise they
// would only be torn down with the heap, after Node.js has stopped.
"还在启动中的 wrapper"是一个容易被忽略的状态。 如果不管,它会在 Node 停止后才被析构,析构时可能调用 V8 API → 崩溃。
2.7 zygote:Linux 的特殊一层
在 Linux 上跑 Electron,进程树会多一个成员:--type=zygote。
2.7.1 zygote 是什么
zygote(受精卵)是 Android 和 Chrome OS 引入的技术,后来被 Chrome 用到 Linux 上。
思路:预先启动一个"干净"的进程,之后所有渲染进程都从这个进程 fork 出来。
好处:
- 快:fork 比 exec + 完整初始化快得多(COW 复制页表,不复制内存);
- 省内存:fork 出来的进程共享父进程的只读页(代码段、资源包),物理内存只算一份;
- 安全:zygote 在 fork 前就把自己"关进沙箱"(chroot、seccomp),fork 出的子进程继承这个受限环境。
2.7.2 Electron 里的 zygote 痕迹
SubprocessNeedsResourceBundle 里有一行:
electron_main_delegate.cc:105
#if BUILDFLAG(IS_LINUX)
// The zygote process opens the resources for the renderers.
process_type == ::switches::kZygoteProcess ||
#endif
注释说明了原因:zygote 要为后续 fork 出的渲染进程预先打开资源包。因为一旦进了沙箱,就再也打不开文件了。
process_util.cc:38-40 里也有对应:
bool IsZygoteProcess() {
static bool result = GetProcessType() == switches::kZygoteProcess;
return result;
}
而 PreSandboxStartup 里对 crashpad 的处理也分了 zygote:
electron_main_delegate.cc:302-303
#if BUILDFLAG(IS_LINUX)
// Zygote needs to call InitCrashReporter() in RunZygote().
if (!IsZygoteProcess() && !IsBrowserProcess()) {
ElectronCrashReporterClient::Create();
...
}
#endif
注释:zygote 的崩溃处理器要在 RunZygote() 里初始化,不能在这里。
为什么? 因为 zygote fork 之后,子进程的 crashpad handler 必须重新绑定(PID 变了)。如果 zygote 阶段就绑死,所有子进程会共用一个错误的 handler。
2.7.3 为什么只有 Linux
- Windows 没有 fork,进程创建走
CreateProcess,而且 Chromium 在 Windows 上用"预创建进程池"达到类似效果。 - macOS 有 fork 但 Cocoa 明确不支持(fork 后不能安全使用 Objective-C runtime),所以 Chromium 在 macOS 上不用 zygote。
- Linux 有 fork 且没有 Cocoa 的限制,所以能用。
这个差异解释了一个现象:Linux 上 Electron 应用启动第一个窗口更快、内存更省。 因为 zygote 已经预热好了。
2.7.4 一个副作用:/proc 里会看到多层进程
electron (browser)
└─ electron --type=zygote
├─ electron --type=renderer
└─ electron --type=renderer
有时候会看到 --type=zygote --no-zygote-sandbox 这样的组合——那是 zygote 的"沙箱外"版本,用于某些需要额外权限的子进程(比如 GPU)。
2.8 Worker、Service Worker 与 webview
除了上面四类,Electron 里还有几种"执行环境",它们不是独立进程,但有自己的 JS 上下文和 process.type。
2.8.1 Web Worker
渲染进程里 new Worker('worker.js') 会创建一个 Worker 线程。它有:
- 自己的 V8 Isolate(不能共享 JS 对象);
- 没有 DOM;
- 可以通过
postMessage与主线程通信; - 在 Electron 里可以有 Node 环境(如果
nodeIntegrationInWorker: true)。
最后一条是 Electron 特有的。默认 false,因为给 Worker 开 Node 意味着每个 Worker 都是一个潜在的文件系统访问点。
process.type 在 Worker 里是 'worker'。
对应的 bundle 是 worker_init.js(第 1 章那张表)。加载逻辑在 lib/worker/init.ts。
2.8.2 Service Worker
Service Worker 是"页面的后台代理",能做离线缓存、推送通知、后台同步。
Electron 支持它,但主进程需要能感知和控制。这通过 ServiceWorkerMain 实现:
electron_api_service_worker_main.cc:93
ServiceWorkerMain::ServiceWorkerMain(content::ServiceWorkerContext* sw_context, ...)
它的 API 包括:
| 方法/事件 | 作用 |
|---|---|
startTask() | 延长 Service Worker 的生命周期,防止它被回收 |
send(channel, ...args) | 向 Service Worker 发消息 |
running-status-changed | 运行状态变化 |
destroy() | 强制销毁 |
startTask 的存在说明了一个 Service Worker 的固有问题:浏览器可以在任何时候杀掉空闲的 Service Worker。 如果你有一个长任务,必须显式"占住"它。
对应的事件在 session.serviceWorkers 上:
session.defaultSession.serviceWorkers.on('running-status-changed', (event) => {
console.log(event.versionId, event.runningStatus)
})
2.8.3 webview 标签
<webview> 是 Electron 的"内嵌浏览器"组件。它必须跑在独立进程里(guest 进程),这是安全设计:
- guest 不能访问 embedder 的 JS 对象;
- guest 的崩溃不影响 embedder;
- 通信必须通过
postMessage/ipc-message。
实现上,webview 的 guest 是一个 WebContents,类型是 kWebView(见 api::WebContents::Type 枚举)。
webview_bundle.js 就是注入到 guest 页面里的脚本,负责把 webview 标签的 API 桥接到 guest 的 window。
注意:官方文档一直把 <webview> 标为"不稳定",推荐用 WebContentsView 替代。但它的代码仍然完整保留,因为大量存量应用依赖它。
2.8.4 四种环境的对照表
| 环境 | 进程 | process.type | Node | DOM | 沙箱 |
|---|---|---|---|---|---|
| 主进程 | browser | browser | ✅ 完整 | ❌ | ❌ |
| 渲染进程(无 Node) | renderer | renderer | ❌ | ✅ | ✅ |
| 渲染进程(有 Node) | renderer | renderer | ✅ | ✅ | ❌ |
| preload(隔离世界) | renderer | renderer | ✅(受限) | ✅(隔离) | 取决于配置 |
| Web Worker | renderer 内线程 | worker | 可选 | ❌ | 跟随进程 |
| Service Worker | renderer 内线程 | worker | ❌ | ❌ | 跟随进程 |
| utility process | utility | utility | ✅ | ❌ | ❌ |
| ELECTRON_RUN_AS_NODE | browser(伪) | browser | ✅ | ❌ | ❌ |
这张表值得存下来。遇到"这个 API 为什么不能用"的问题,先查表。
2.9 进程之间怎么说话:mojo 与四个接口
有了四个进程,下一个问题是它们怎么通信。答案不是"IPC",而是比 IPC 更底层的一整套东西:mojo。
2.9.1 mojo 是什么
mojo 是 Chromium 的 IPC 系统,包含四层:
┌─────────────────────────────────────────┐
│ 接口层:mojom IDL 定义 .mojom 文件 │
├─────────────────────────────────────────┤
│ 绑定层:生成的 C++ 代理类与存根 │
├─────────────────────────────────────────┤
│ 消息层:Message、MessagePipe、Connector │
├─────────────────────────────────────────┤
│ 传输层:平台相关的 IPC(Unix socket / │
│ Windows named pipe)+ 共享内存 │
└─────────────────────────────────────────┘
关键概念:
- MessagePipe:一条双向消息管道,两端各持一个 endpoint;
- Interface:一组方法,绑定到一个 pipe 的一端;
- Receiver / Remote:接收端与发送端的 C++ 对象;
- Associated interface:与另一条 pipe 的消息保持顺序关系的接口。
最后一条很重要。看 api.mojom 里的注释:
api.mojom:52
// Per-frame interface associated with content.mojom.Frame, so its messages and
// replies are ordered with navigation and the frame's other host messages:
// SetStartupData() arrives before the CommitNavigation that follows it, and a
// reply is seen after anything the frame told its host while handling the
// request.
interface ElectronFrame {
"associated with" 的意思是:这条接口的消息与 content.mojom.Frame 的消息共享顺序。
为什么需要这个?因为如果 preload 脚本的推送(SetStartupData)和导航提交(CommitNavigation)走两条独立的管道,接收顺序就无法保证——可能出现"页面已经开始执行,preload 还没到"的灾难。
这就是 Electron 45 里一个重要的架构改进:把 preload 数据从"另一条管道"改成"与 frame 关联的接口"。
注释里那句 "SetStartupData() arrives before the CommitNavigation that follows it" 就是承诺。
2.9.2 五个接口,五条通道
api.mojom:52-59 定义了 Electron 的核心通信接口。逐个看。
ElectronFrame:帧级能力
api.mojom:52-59
interface ElectronFrame {
SetStartupData(RendererStartupData data);
ExecuteJavaScript(int32 world_id,
array<ScriptSource> sources,
bool has_user_gesture)
=> (bool success, SerializedValue result, string error);
InsertCSS(string css, string css_origin) => (mojo_base.mojom.String16 key);
RemoveInsertedCSS(mojo_base.mojom.String16 key) => ();
InsertText(string text) => ();
SetVisualZoomLevelLimits(double min_level, double max_level) => ();
ReceiveSharedTexture(SerializedValue transfer, string texture_id, SerializedValue args)
=> (bool success, SerializedValue result, string error);
};
六个方法,覆盖:
| 方法 | 对应 JS API |
|---|---|
SetStartupData | 内部:推送 preload 脚本 |
ExecuteJavaScript | webContents.executeJavaScript() |
InsertCSS | webContents.insertCSS() |
RemoveInsertedCSS | webContents.removeInsertedCSS() |
InsertText | webContents.insertText() |
SetVisualZoomLevelLimits | webContents.setVisualZoomLevelLimits() |
ReceiveSharedTexture | sharedTexture 相关 |
注意 ExecuteJavaScript 的返回类型:(bool success, SerializedValue result, string error)。
三态设计:
success = true:result是脚本的完成值(如果是 thenable 会先 await);success = false且error为空:result是抛出的值或被 reject 的值;success = false且error非空:发生了"没产生值"的失败(比如 frame 已经销毁)。
注释写得很清楚:
// |result| is the script's completion value (a thenable is awaited first) when
// |success|, otherwise the value it threw or rejected with, unless |error|
// describes a failure that produced no value. |world_id| 0 is the main world.
为什么不用一个 SerializedValue? 加一个 string?? 因为要区分"抛出了 undefined"和"根本没执行"。这两种情况在 JS 侧的表现完全不同:前者应该 reject 一个 undefined,后者应该 reject 一个 Error。
这是一个 API 设计细节,但它决定了 await webContents.executeJavaScript('undefined') 的行为是否符合直觉。
ElectronRenderer:主 → 渲染
api.mojom:80-83
interface ElectronRenderer {
Message(bool internal, string channel, SerializedValue arguments);
ReceivePostMessage(string channel, blink.mojom.TransferableMessage message);
TakeHeapSnapshot(handle file) => (bool success);
};
三个方法:
Message:主进程往渲染进程发 IPC 消息(webContents.send);ReceivePostMessage:发MessagePort消息;TakeHeapSnapshot:抓堆快照(webContents.takeHeapSnapshot)。
bool internal 这个参数值得说:它区分"公开通道"与"内部通道"。
内部通道用于 Electron 自己的框架通信(比如 ipcRendererInternal),用户代码监听不到。这个隔离防止用户劫持框架的消息。
ElectronApiIPC:渲染 → 主
api.mojom:100-107
interface ElectronApiIPC {
Message(bool internal, string channel, SerializedValue arguments);
Invoke(bool internal, string channel, SerializedValue arguments)
=> (SerializedValue result);
ReceivePostMessage(string channel, blink.mojom.TransferableMessage message);
[Sync]
MessageSync(bool internal, string channel, SerializedValue arguments)
=> (SerializedValue result);
MessageHost(string channel, SerializedValue arguments);
};
五个方法,正好对应 ipcRenderer 的五个发送 API:
| mojom 方法 | JS API | 语义 |
|---|---|---|
Message | ipcRenderer.send | 单向,不等回复 |
Invoke | ipcRenderer.invoke | 双向,返回 Promise |
MessageSync | ipcRenderer.sendSync | 同步,阻塞渲染进程 |
MessageHost | ipcRenderer.sendToHost | 发给 <webview> 的宿主 |
ReceivePostMessage | port.postMessage | MessagePort |
[Sync] 那个注解是 mojo 的同步调用标记。它会让调用方阻塞,直到对方返回。
这是性能陷阱的来源:sendSync 会阻塞渲染进程的主线程,而主进程的 UI 线程如果正忙,渲染进程就卡在那里。Chromium 内部对同步 IPC 有严格限制,Electron 保留它主要是为了向后兼容。
ElectronAutofillAgent / ElectronAutofillDriver
自动填充相关,两组接口一对:
api.mojom:91-96
interface ElectronAutofillAgent {
AcceptDataListSuggestion(mojo_base.mojom.String16 value);
};
interface ElectronAutofillDriver {
ShowAutofillPopup(gfx.mojom.RectF bounds, array<mojo_base.mojom.String16> values,
array<mojo_base.mojom.String16> labels);
HideAutofillPopup();
};
这是 Electron 45 相对较新的能力:原生自动填充下拉框。agent 在渲染进程侧(报告用户选择了哪一项),driver 在浏览器侧(显示/隐藏原生弹窗)。
2.9.3 序列化:SerializedValue
注意所有消息参数都是 SerializedValue:
api.mojom:37-39
struct SerializedValue {
mojo_base.mojom.BigBuffer buffer;
uint64 size;
};
不是 mojo_base.mojom.Value,不是 string,而是"一个字节缓冲区 + 长度"。
为什么?因为 Electron 需要自己控制序列化格式,以支持 JS 特有的值:
undefined(mojo 的Value不支持);Date、RegExp、Map、Set;ArrayBuffer、TypedArray;- 循环引用(structured clone 支持);
Error对象(带 stack)。
所以 Electron 自己实现了一套序列化(electron::SerializeV8Value),产出的字节流装进 BigBuffer。
注释里还点出一个实现细节:
// A value serialized with electron::SerializeV8Value(), in the buffer it is
// sent in. |buffer| may be larger than the |size| bytes that were written.
缓冲区可能比实际数据大。 因为 BigBuffer 有对齐要求,分配时会向上取整。读取时必须以 size 为准,不能读整个 buffer。
这种"容量 ≥ 长度"的约定在二进制协议里很常见,但忘记它会读到垃圾数据。
2.9.4 一次 ipcRenderer.invoke 的完整路径
把上面所有东西串起来:
渲染进程 主进程
───────── ────────
ipcRenderer.invoke('ch', a, b)
│
├─ 序列化:SerializeV8Value([a, b])
│ → BigBuffer(字节流)
│
├─ mojo: ElectronApiIPC::Invoke(internal=false, "ch", args)
│ │
│ ├─ Connector 发送消息
│ │ └─ 写入 MessagePipe
│ │ └─ 平台 IPC(Unix socket / named pipe)
│ │ ↓
│ │ 主进程 IO 线程收到字节
│ │ └─ mojo 反序列化 → 参数对象
│ │ └─ PostTask 到 UI 线程
│ │ ↓
│ └────────────────────────┴─▶ ElectronApiIPCHandlerImpl::Invoke()
│ └─ ipc_dispatch::Message(...)
│ └─ 调用 JS: ipcMain 的监听器
│ └─ 返回 Promise
│ └─ 等 Promise resolve
│ └─ 序列化结果
│ └─ callback(result)
├─ mojo 回复到达(IO 线程 → 渲染线程)
└─ 反序列化 → resolve Promise
这条路径上有 4 次线程切换、2 次序列化、1 次进程边界。
一个空消息的往返时间在 0.1-0.5 ms。如果你的应用每秒发 1000 条 IPC,光这部分就吃掉 10-50% 的一帧时间。
2.9.5 为什么不用共享内存
有人会问:为什么要序列化?为什么不共享内存?
因为进程隔离的前提就是不能共享内存。如果两个进程能直接读写同一块内存,那么任何一个进程的漏洞都能读写另一个进程的数据——隔离就失效了。
mojo 提供了"共享内存"能力(mojo_base.mojom.BigBuffer 在小数据时内联、大数据时用共享内存),但那仍然是"复制进去再读出来"的语义,只是避免了拷贝开销。指针本身绝不跨进程。
Electron 里唯一绕过这条规则的是 sharedTexture(第 13 章),它传的是 GPU 纹理句柄,本质是驱动层的资源句柄,不是内存指针。
2.10 崩溃、重启与死亡通知
多进程架构最大的好处是"崩一个不崩全部",但前提是你得知道它崩了。
2.10.1 三类崩溃
| 类型 | 表现 | 处理者 |
|---|---|---|
| 渲染进程崩溃 | 页面白屏,render-process-gone 事件 | 应用代码 |
| GPU 进程崩溃 | 白屏或花屏,child-process-gone | Chromium 自动重启 |
| 主进程崩溃 | 应用消失 | 只能靠外部看护 |
2.10.2 render-process-gone
渲染进程崩溃时,webContents 会发事件:
win.webContents.on('render-process-gone', (event, details) => {
console.log(details.reason) // 'crashed' | 'oom' | 'killed' | ...
console.log(details.exitCode)
})
reason 的取值来自 Chromium 的 base::TerminationStatus 映射,常见值:
clean-exit:正常退出abnormal-exit:异常退出killed:被信号杀死(比如 OOM killer)crashed:段错误oom:内存耗尽launch-failed:启动失败integrity-failure:代码完整性检查失败(macOS 特有)
oom 和 killed 的区别值得注意:oom 是 V8 堆耗尽(进程自己知道),killed 是操作系统杀的(进程不知道,父进程从 exit code 推断)。
2.10.3 Browser::RenderProcessExited
在主进程侧,崩溃会先经过 ElectronBrowserClient:
electron_browser_client.cc:1129-1136
void ElectronBrowserClient::RenderProcessExited(
content::RenderProcessHost* host,
const content::ChildProcessTerminationInfo& info) {
if (delegate_) {
static_cast<api::App*>(delegate_)->RenderProcessExited(host);
}
}
delegate_ 就是 api::App——也就是 JS 的 app 对象。所以这条路径最终会走到 app 的 C++ 实现,再发事件。
注意 delegate_ 可能为空:如果 app 已经被销毁(退出流程中),这里直接跳过。这是一个必要的空检查。
2.10.4 恢复策略
Electron 不会自动重建崩溃的渲染进程。你需要自己处理:
crash-reporting.md:222-224
win.webContents.on('render-process-gone', (event, details) => {
if (details.reason === 'clean-exit') return
// 重载页面(会触发新进程)
win.webContents.reload()
})
但"直接 reload"有风险:如果崩溃是必现的(比如某个页面的 bug),会进入无限崩溃循环。
生产环境的做法是加计数与降级:
let crashCount = 0
win.webContents.on('render-process-gone', (event, details) => {
crashCount++
if (crashCount <= 3) {
setTimeout(() => win.reload(), 100 * crashCount)
} else {
win.loadFile('crash.html')
}
})
2.10.5 一个真实场景:无限崩溃循环
现象:应用启动后窗口一闪一闪,CPU 100%。
原因:render-process-gone 处理里直接 reload(),而崩溃原因是"页面加载时必崩的某个操作"。
诊断:看 details.reason 与 exitCode,如果是 crashed 且每次都在同一位置,说明是必现 bug。
为什么 Chromium 不会阻止你:因为 reload() 是应用代码主动调的,Chromium 认为是"用户意图"。Chromium 自己有一个 "sad tab" 机制(崩溃后显示一个悲伤的表情页),但 Electron 没有启用它。
2.10.6 主进程崩溃
主进程崩了,应用就没了。这时候唯一能做的:
- crashReporter 收集 dump(第 20 章);
- 外部看护:Linux 的 systemd、Windows 的服务、macOS 的 launchd;
app.relaunch()+app.exit():在崩溃前主动重启(比如捕获到uncaughtException后)。
但注意:uncaughtException 捕获不等于"进程安全"。异常的栈可能已经破坏了状态,重启是唯一可靠的选择。
Electron 的默认行为是弹窗提示(lib/browser/init.ts),这适合开发期,不适合生产。生产环境应该自己处理:
process.on('uncaughtException', (err) => {
log.error(err)
// 上报、清理、重启
app.relaunch()
app.exit(1)
})
2.11 进程模型如何决定应用架构
前面九节都是"是什么"。这一节是"所以呢"——进程模型如何影响你写应用的方式。
2.11.1 把工作放在正确的进程里
这是最重要的一个决策,也是最容易做错的。
判断依据:这个工作会不会阻塞、会不会崩溃、要不要访问敏感资源。
任务 放哪 理由
────────────────────────────────────────────────────────────────
UI 交互、窗口管理 主进程 必须在 UI 线程
DOM 操作、页面渲染 渲染进程 只能在 Blink 里
CPU 密集计算(图像、加密) utility process 不阻塞 UI,崩溃可恢复
大量文件 IO utility process 不阻塞 UI 线程
网络请求(应用级) 主进程(net 模块) 统一 cookie/代理
网络请求(页面级) 渲染进程(fetch) 同源策略、cookie 自动带
数据库(SQLite) utility process 避免锁 UI
原生模块(.node) 主进程或 utility 不能在沙箱渲染进程
视频解码 GPU 进程(自动) 浏览器内部处理
三条容易踩的线:
第一,"主进程也能做计算"不等于"应该做"。
主进程做 crypto.pbkdf2Sync 10 万次迭代,会让整个 UI 卡 2 秒。用户看到的是"应用卡死"。
第二,渲染进程做重活会阻塞页面。
页面里的 while 循环会冻结滚动、输入、动画。即使不影响主进程,用户体验也是灾难。
第三,utility process 不是万能的。
它有启动成本(约 30-80ms),不适合"每个小任务 fork 一次"。正确的模式是进程池:启动 N 个,复用。
class WorkerPool {
constructor(size, scriptPath) {
this.idle = []
this.queue = []
for (let i = 0; i < size; i++) {
const child = utilityProcess.fork(scriptPath, [], { stdio: 'inherit' })
child.on('message', (msg) => this._onMessage(child, msg))
child.on('exit', () => this._onExit(child))
this.idle.push(child)
}
}
run(task) {
return new Promise((resolve, reject) => {
const job = { task, resolve, reject }
const child = this.idle.pop()
if (child) this._dispatch(child, job)
else this.queue.push(job)
})
}
_dispatch(child, job) {
this.current = child
child.job = job
child.postMessage(job.task)
}
_onMessage(child, msg) {
const job = child.job
child.job = null
job.resolve(msg)
const next = this.queue.shift()
if (next) this._dispatch(child, next)
else this.idle.push(child)
}
_onExit(child) {
// 崩溃:拒绝当前任务,补一个新进程
if (child.job) child.job.reject(new Error('worker crashed'))
const idx = this.idle.indexOf(child)
if (idx >= 0) this.idle.splice(idx, 1)
}
}
这段代码里有一个容易被忽略的细节:_onExit 里没有补新进程。 生产版本应该补,否则进程池会越用越少。我故意留着,是因为它正好说明"进程会死"这件事必须显式处理。
2.11.2 IPC 的三个模式
进程分开了,通信模式就三种:
模式 A:请求-响应(invoke)
// 渲染进程
const result = await ipcRenderer.invoke('read-config')
// 主进程
ipcMain.handle('read-config', async () => {
return JSON.parse(await fs.promises.readFile(configPath, 'utf8'))
})
适合:查询、提交表单、读配置。有明确的一问一答。
模式 B:单向通知(send)
// 渲染进程
ipcRenderer.send('log', { level: 'info', msg: 'clicked' })
// 主进程
ipcMain.on('log', (event, payload) => logger.log(payload))
适合:日志、埋点、状态上报。不需要回复,丢了也不致命。
模式 C:流(MessagePort)
// 主进程
const { port1, port2 } = new MessageChannelMain()
worker.postMessage({ port: port2 }, [port2])
port1.on('message', (e) => console.log(e.data))
// 渲染进程 / utility
process.parentPort.on('message', (e) => {
const [port] = e.ports
port.on('message', (ev) => { ... })
})
适合:持续数据流(进度、日志流、大文件分块)、点对点通信(两个渲染进程直连)。
MessagePort 的关键优势:它是一条独立的管道,不经过主进程转发。
两个渲染进程之间传大数据,用 MessagePort 可以避免"渲染 A → 主 → 渲染 B"的两跳。代价是端口传递必须经过主进程一次(建立连接),之后直连。
2.11.3 一个具体的架构决策:单窗口 vs 多窗口 vs 多进程
假设你要做一个"打开 10 个标签页"的应用。三种设计:
设计 1:10 个 BrowserWindow
主进程
├─ 窗口 1 → 渲染进程 1
├─ 窗口 2 → 渲染进程 2
...
└─ 窗口 10 → 渲染进程 10
内存:约 10 × 60MB + 主进程 120MB = 720MB。 优点:隔离最好,一个崩了不影others。 缺点:内存高,进程多,启动慢。
设计 2:1 个窗口 + 10 个 WebContentsView
主进程
└─ 窗口 1
└─ View 容器
├─ WebContentsView 1 → 渲染进程 1
├─ WebContentsView 2 → 渲染进程 2
...
└─ WebContentsView 10 → 渲染进程 10
内存:大致相同(还是 10 个渲染进程),但少 9 个原生窗口的开销(约 5-10MB each)。 优点:可以做"标签页"UI,切换快,共享窗口的菜单/快捷键。 缺点:布局要自己管,焦点管理复杂。
设计 3:1 个窗口 + 1 个 WebContents + 内部路由
主进程
└─ 窗口 1 → 渲染进程 1(单页应用,自己管"标签")
内存:约 60MB + 120MB = 180MB。 优点:最省内存,启动最快。 缺点:一个页面崩溃全崩,无法做到"每个标签独立 session"。
选择依据不是"哪个更先进",而是"隔离需求 vs 资源约束"。
浏览器类应用必须选 2(隔离是核心需求);内部工具选 3(省钱、简单);需要多个独立登录态的应用选 2 且每个 View 用不同 partition。
2.11.4 内存:那些不会告诉你的数字
实测数据(Electron 45,Windows 11,8 核 16G):
| 场景 | 主进程 | 每个渲染进程 | GPU | 总计 |
|---|---|---|---|---|
| 空窗口(about:blank) | 95 MB | 45 MB | 60 MB | 200 MB |
| 加载简单页面 | 110 MB | 70 MB | 75 MB | 255 MB |
| 加载复杂 SPA | 130 MB | 150 MB | 110 MB | 390 MB |
| + DevTools 打开 | 130 MB | +80 MB | 110 MB | 470 MB |
几个结论:
- 主进程的基础开销在 100MB 量级,这部分省不掉(V8 + Node + content 层)。
- 每个渲染进程 45-150MB,取决于页面复杂度。
- GPU 进程 60-110MB,即使你不做图形也跑。
- DevTools 很贵,生产环境不要开。
优化方向:
- 减少窗口数(用 View 替代 Window);
- 页面加载后调用
webContents.setBackgroundThrottling(false)只在必要时; - 用
webContents.session.clearCache()控制缓存增长; - 及时
destroy()不用的 WebContents(不是close(),close()只是关窗口)。
2.11.5 进程与启动时间
冷启动一个 Electron 应用的时间构成(实测,SSD,Windows):
总时长 1.2s
├─ 进程创建 + Chromium 初始化 250ms
├─ V8 + Node 初始化 180ms
├─ browser_init.js 执行 60ms
├─ 用户 main.js 执行 80ms
├─ 创建窗口(原生) 120ms
├─ 渲染进程创建 180ms
├─ 页面加载 + 首帧 300ms
└─ 其他 30ms
注意"渲染进程创建"那 180ms。 这是可以优化的部分:
// 提前预热(Electron 内部有 spare renderer 机制)
// 或者:启动时立刻创建一个隐藏窗口,让进程池有货
const warmup = new BrowserWindow({ show: false })
warmup.loadURL('about:blank')
第 23 章会给出完整的启动优化清单。
2.11.6 一个反模式:把主进程当"后端服务器"
很多团队会这样设计:
主进程 = 业务逻辑 + 数据访问 + 窗口管理 + IPC 路由
渲染进程 = 纯 UI
这在小应用里没问题,在中等规模应用里会变成灾难:
- 主进程变成一个巨型单例,任何模块都能改它的状态;
- IPC 通道数量爆炸(几十个 handler);
- 主进程一崩全崩,而且因为逻辑复杂,崩的概率高。
更好的分层:
┌──────────────────────────────────────────┐
│ 渲染进程:UI、交互、展示 │
├──────────────────────────────────────────┤
│ 主进程:只做"系统能力代理" │
│ · 窗口/菜单/托盘 │
│ · 文件对话框 │
│ · 权限决策 │
│ · IPC 路由(薄) │
├──────────────────────────────────────────┤
│ utility process:业务逻辑、数据、计算 │
│ · 崩溃可恢复 │
│ · 可以用 worker_threads 进一步并行 │
└──────────────────────────────────────────┘
这个分层的核心思想:把"会崩的、会卡的"推到 utility process。
代价是多了 IPC 开销,收益是主进程足够简单,简单到不容易崩。
2.11.7 进程模型的"物理定律"
最后给三条不可违背的规律,它们决定了架构的边界:
定律一:跨进程的数据必须可序列化。
你不能把 DOM 节点、函数、class 实例传给另一个进程。能传的只有:原始值、普通对象、数组、Date、RegExp、Map、Set、ArrayBuffer、TypedArray、Error、MessagePort。
定律二:跨进程的调用都是异步的(除了 sendSync)。
没有"同步读另一个进程的内存"。所有"同步"API 要么是本地缓存,要么是阻塞等待(性能陷阱)。
定律三:进程边界就是崩溃边界。
一个进程崩了,它的所有内存状态消失。所以任何需要持久的状态都必须落在进程之外(磁盘、数据库、或者主进程)。
第三条最容易被忽略。很多应用把"用户的编辑内容"只放在渲染进程的内存里,崩溃一次就全丢。正确做法是每次编辑都通过 IPC 落到主进程或磁盘。
2.12 十二个进程相关的高频问题
1. 为什么我的应用有 5 个进程,但我只开了 1 个窗口?
主进程 + GPU + 网络服务(可能是独立进程)+ 渲染进程 + 可能还有一个预热的渲染进程。
用 app.on('child-process-gone') 和 webContents.getOSProcessId() 可以看清谁是谁。
2. webContents.getOSProcessId() 和 process.pid 有什么区别?
process.pid 是当前进程的 OS PID。webContents.getOSProcessId() 返回渲染进程的 OS PID。
在渲染进程里调 process.pid 得到的是它自己;在主进程里调 webContents.getOSProcessId() 得到的是对应渲染进程。
3. 两个窗口能共享一个渲染进程吗?
能,但不受你直接控制。Chromium 的进程复用策略决定:同站点、同 SiteInstance 的页面会复用。
你可以间接影响:用不同 partition 强制不同进程;用 webPreferences.contextIsolation 影响 site instance 的划分。
4. --no-sandbox 到底关了什么?
关掉了操作系统的进程沙箱(Linux 的 seccomp-bpf + namespace、Windows 的 job object/restricted token、macOS 的 seatbelt)。
后果:渲染进程一旦被攻破,攻击者直接拿到用户权限。
生产环境绝不要用,除非你在容器里(容器本身提供了隔离)。
5. 为什么 child_process.fork() 在打包后失败?
因为 fork 需要找到 Electron 二进制,而打包后路径变了。正确做法是用 utilityProcess.fork(),或者显式设置 execPath: process.execPath + env: { ELECTRON_RUN_AS_NODE: '1' }。
6. worker_threads 在 Electron 里能用吗?
能用,但有坑:Worker 里默认没有完整 Node 环境(需要 nodeIntegrationInWorker),而且 Worker 的错误处理与主线程不同(worker.on('error') 必须监听,否则整个进程崩)。
7. 如何知道某个渲染进程用了多少内存?
const pid = win.webContents.getOSProcessId()
console.log(app.getAppMetrics()) // 按进程列出 CPU/内存
app.getAppMetrics() 返回每个进程的 memory.workingSetSize(KB)。
8. 进程间传大文件(几百 MB)怎么做?
不要用 IPC 传 buffer(会复制多次)。三种做法:
MessagePort+ 分块;- 写临时文件,传路径;
- 用
sharedTexture传 GPU 纹理(仅图形)。
9. 为什么 utility process 里 process.type 是 'utility',但 app 不存在?
因为 app 是主进程专属模块。utility process 的模块表里没有它。
你可以在 utility process 里用 process.parentPort 与主进程通信,但拿不到 app。
10. webContents.getProcessMemoryInfo() 返回的是什么?
渲染进程的内存信息,通过 IPC 从渲染进程查(process.getProcessMemoryInfo() 的跨进程版本)。包含 private、shared、residentSet 等字段。
调用是异步的,因为要跨进程。
11. 为什么 GPU 进程占内存很高,但我的应用没有图形?
因为 Chromium 的合成器总是跑(即使只有文本),而且 GPU 进程会分配纹理缓存、着色器缓存。
如果你的应用完全不需要硬件加速,可以:
app.disableHardwareAcceleration()
这会让 GPU 进程退化(甚至不启动),但渲染性能下降。
12. 进程数能通过配置减少吗?
可以部分控制:
app.commandLine.appendSwitch('renderer-process-limit', '4'):限制渲染进程数;app.commandLine.appendSwitch('disable-gpu'):不启 GPU 进程;app.commandLine.appendSwitch('single-process'):单进程模式,仅用于调试,绝不用于生产(会崩得很惨)。
single-process 这个开关存在本身就是一个警告:它把所有东西塞进一个进程,隔离完全失效。它只用于排查"是不是进程间通信的问题"。
2.13 沙箱:进程模型的最后一层
进程边界给了"内存隔离",但不给"权限隔离"。一个渲染进程即使不能读别人的内存,它仍然可以用自己的身份打开任意文件、连接任意地址。
沙箱要解决的就是这件事:让渲染进程即使被完全控制,也做不了什么。
2.13.1 三个平台的三种实现
| 平台 | 机制 | 关键点 |
|---|---|---|
| Linux | 命名空间(user/pid/net/mount)+ seccomp-bpf + chroot | 需要 kernel 支持,容器里常受限 |
| Windows | 受限令牌 + Job Object + 完整性级别 + AppContainer | 需要 Vista+,Win7 上部分降级 |
| macOS | Seatbelt(sandbox_init 的 SBPL profile) | profile 文件随 app bundle 分发 |
三者的共同思路:先把进程关进一个"空房间",然后只开必要的门。
- 渲染进程:几乎不开门(不能读文件、不能建 socket、不能 fork);
- GPU 进程:开 GPU 设备的门;
- 网络服务:开 socket 的门;
- utility process:不开沙箱(第 2.6.5 节)。
2.13.2 Electron 的沙箱开关链路
从 JS 到操作系统,一个 sandbox: true 要经过四层:
JS: new BrowserWindow({ webPreferences: { sandbox: true } })
│
├─▶ WebContentsPreferences 记录该值
│
├─▶ RenderProcessHost 创建时读取
│ └─▶ 决定子进程命令行:--enable-sandbox / --no-sandbox
│
├─▶ ElectronMainDelegate::PreSandboxStartup
│ └─▶ 若 --no-sandbox:不初始化沙箱
│
└─▶ content::ZygoteHostImpl / SandboxHostLinux(Linux)
或 SandboxBroker(Windows)
或 seatbelt profile 编译(macOS)
关键分叉点在第二步:沙箱是"进程级"的属性,不是"窗口级"。
这意味着:同一个渲染进程里的所有 frame 共享沙箱状态。 如果两个同站点的窗口复用了同一个进程,其中一个要求 sandbox: true、另一个要求 false,矛盾无法调和——Chromium 会用"先到者"的设置,或者干脆不复用。
这就是"为什么改了 sandbox 有时不生效"的根源:进程已经存在了,属性改不了。
2.13.3 沙箱里能做什么
一个 sandbox: true 的渲染进程:
- ✅ 执行 JS、渲染 DOM;
- ✅ 通过
fetch/XHR发网络请求(请求实际由主进程的网络服务发出); - ✅ 访问
localStorage/IndexedDB(实际存储在浏览器进程管理的文件里,通过 IPC 代理); - ✅ 用
postMessage与 preload 通信; - ❌ 读任意文件(包括
fs.readFile); - ❌ 创建子进程;
- ❌ 加载原生模块;
- ❌ 直接访问 GPU 设备。
注意第三条:localStorage 在沙箱进程里"能用",但它的实现是 IPC 代理。沙箱进程只负责把键值发出去,真正写文件的是浏览器进程。
这解释了一个性能现象:沙箱模式下的 localStorage 比非沙箱慢(多了一次 IPC)。
2.13.4 preload 在沙箱里怎么活
这是最容易困惑的地方:sandbox: true 的渲染进程没法 require('fs'),但 preload 里却能拿到一部分 Node API。
答案:沙箱 preload 是一个"受限的 polyfill 环境"。
preload.ts(以及 lib/isolated_renderer/)提供了一套替代实现:
| preload 里能用的 | 实现方式 |
|---|---|
require('electron') | 只暴露 ipcRenderer、contextBridge、webFrame 等少数模块 |
process | 一个受限的鸭子类型对象(有 platform、versions,没有 binding) |
Buffer | 真实的 Buffer 实现(纯 JS,从 bundle 里加载) |
require('fs') | ❌ 抛错 |
require('path') | ✅ 纯 JS 实现,可用 |
require('events') | ✅ 纯 JS,可用 |
所以"沙箱 preload 里能不能 require"的准确答案是:能 require 一部分纯 JS 模块,不能 require 任何需要系统调用的模块。
这个边界在 lib/sandboxed_renderer/ 的模块表里定义。第 12 章会给出完整列表。
2.13.5 一个必须接受的取舍
沙箱带来安全性,代价是:
- preload 能做的事变少:不能直接读文件,必须通过 IPC 请求主进程;
- 性能略降:每个受限于 IPC 的操作都多一次往返;
- 调试更麻烦:崩溃栈里少了很多信息(符号被剥离是沙箱的一部分);
- 原生模块不可用:任何
.node文件都不能在沙箱里加载。
Electron 的默认值在最近几个版本里变过:sandbox 现在默认跟随 nodeIntegration(后者为 false 时 sandbox 默认 true)。这是一个明确的方向:默认安全,需要能力就显式关掉。
2.14 如何调试进程问题
进程相关的问题最难调,因为现象往往"不在这条进程里"。这一节给一套可操作的方法。
2.14.1 第一步:把进程树打出来
// 主进程
app.whenReady().then(() => {
setTimeout(() => {
const metrics = app.getAppMetrics()
for (const m of metrics) {
console.log(
m.type.padEnd(10),
'pid=' + m.pid,
'cpu=' + m.cpu.percentCPUUsage.toFixed(1) + '%',
'mem=' + Math.round(m.memory.workingSetSize / 1024) + 'MB'
)
}
}, 3000)
})
输出示例:
Browser pid=1024 cpu=2.1% mem=112MB
Tab pid=1040 cpu=0.3% mem=68MB
GPU pid=1031 cpu=1.2% mem=74MB
Utility pid=1055 cpu=0.0% mem=22MB
m.type 的取值:Browser、Tab、GPU、Utility、Zygote、Sandbox helper、Pepper Plugin、Pepper Plugin Broker、Unknown。
2.14.2 第二步:定位是哪个渲染进程
// 遍历所有 WebContents,打印 OS PID 与 URL
const { webContents } = require('electron')
for (const wc of webContents.getAllWebContents()) {
console.log(wc.id, wc.getOSProcessId(), wc.getURL())
}
wc.id 是 Electron 内部的 WebContents ID(从 1 开始递增),getOSProcessId() 是操作系统 PID。
两个 ID 不要混用:wc.id 用于 webContents.fromId(),OS PID 用于 process.kill() 或性能分析工具。
2.14.3 第三步:抓渲染进程的崩溃现场
开启崩溃报告:
crashReporter.start({ submitURL: '', uploadToServer: false })
崩溃后 dump 文件在:
Windows: %APPDATA%\<AppName>\Crashpad\reports\
macOS: ~/Library/Application Support/<AppName>/Crashpad/reports/
Linux: ~/.config/<AppName>/Crashpad/reports/
分析 dump 需要符号文件(electron-v45.2.3-win32-x64-pdb.zip 之类),从 Electron 的 release 页面下载。
这一步的门槛在于:符号文件很大(几百 MB),而且必须版本完全匹配。 生产环境通常把 dump 上传到 Sentry 或自建服务,让服务端做符号化。
2.14.4 第四步:用 Chromium 的日志
# 打开所有日志
electron . --enable-logging --v=1
# 只看特定模块
electron . --enable-logging --vmodule=render_process_host=2
--vmodule 是 Chromium 的按文件设置日志级别的机制,格式是 文件名前缀=级别。
常用的:
--vmodule=render_process_host=2 进程创建/销毁
--vmodule=ipc=2 IPC 消息
--vmodule=web_contents=2 WebContents 生命周期
这些日志非常啰嗦,但它们是唯一能看到"进程内部发生了什么"的窗口。
2.14.5 第五步:一个真实案例
症状:应用运行 2 小时后,切窗口变得极慢(2-3 秒)。
排查过程:
app.getAppMetrics()→ 发现渲染进程数量从 3 涨到 47。- 遍历
webContents.getAllWebContents()→ 发现 47 个 WebContents,其中 44 个的 URL 是about:blank。 - 定位代码:某个"打开预览"的功能每次
new BrowserWindow()但关闭时只win.hide(),没win.destroy()。 - 修复:改用
WebContentsView复用,或关闭时destroy()。
这个案例的教训:hide() 不等于销毁。 隐藏的窗口仍然占着一个渲染进程,仍然占内存,仍然参与合成。
2.14.6 一组诊断命令
# 看进程树(Linux/macOS)
pstree -p $(pgrep -f "YourApp" | head -1)
# 看每个进程的线程数
ps -T -p <pid> | wc -l
# 看 GPU 进程是否在
ps aux | grep "type=gpu-process"
# 看子进程的命令行(Linux)
tr '\0' ' ' < /proc/<pid>/cmdline
# 看沙箱状态(Linux)
grep Seccomp /proc/<pid>/status
最后一条能直接告诉你"这个进程到底有没有开 seccomp 沙箱":
Seccomp: 2 ← 2 = 严格模式(filter),说明沙箱生效
Seccomp: 0 ← 0 = 未启用
这是验证"沙箱是否真的开了"最可靠的方法,比相信配置值靠谱。
2.15 单实例锁:进程模型的第一场实战
几乎每个桌面应用都要回答一个问题:用户双击了两次图标,应该开两个窗口,还是把已有的窗口拉到前面?
这个问题看起来是"产品决策",实际上是"进程模型问题"。Electron 的答案在 ProcessSingleton 里。
2.15.1 一个进程、一个锁文件
electron_api_app.cc:1103-1110
// shell/browser/api/electron_api_app.cc:1103-1130(节选)
bool App::RequestSingleInstanceLock(gin::Arguments* args) {
if (HasSingleInstanceLock())
return true;
base::FilePath user_dir;
base::PathService::Get(chrome::DIR_USER_DATA, &user_dir);
// The user_dir may not have been created yet.
base::CreateDirectoryAndGetError(user_dir, nullptr);
auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this));
blink::CloneableMessage additional_data_message;
args->GetNext(&additional_data_message);
// ProcessSingleton keeps a non-owning base::raw_span to this data, so it must
// outlive `process_singleton_`. Copy it into a member that is destroyed after
// `process_singleton_` to avoid a dangling span.
single_instance_additional_data_.assign(
additional_data_message.encoded_message.begin(),
additional_data_message.encoded_message.end());
第一行是幂等检查:已经拿了锁就直接返回 true。这很重要,因为很多应用会在 main.js 里调多次(比如热重载时)。
然后是 user_dir。单实例的判定维度是"用户数据目录",不是"应用名"。
这条规则解释了两个常见现象:
- 同一个应用用不同
--user-data-dir启动,可以同时开多个实例。 这是开发时同时跑 dev 和 prod 的技巧。 - 两个不同的应用如果误用了同一个
userData路径,会互相抢锁。 这通常发生在多个应用共用同一个appId或name时。
接着看 additional_data 那段注释:
// ProcessSingleton keeps a non-owning base::raw_span to this data, so it must
// outlive `process_singleton_`. Copy it into a member that is destroyed after
// `process_singleton_` to avoid a dangling span.
这是一条典型的生命周期陷阱记录。 ProcessSingleton 持有一个"非拥有"的 span(指向 additional_data 的字节),所以那块内存必须比 ProcessSingleton 活得久。解决办法是把它复制到一个成员变量里,并确保成员的析构顺序在 process_singleton_ 之后。
C++ 里成员的析构顺序与声明顺序相反,所以 single_instance_additional_data_ 必须在 process_singleton_ 之前声明——这样它才之后析构。
这类"声明顺序决定析构顺序"的细节,是读 C++ 代码时必须盯住的地方。
2.15.2 平台差异:Windows 多了两个参数
electron_api_app.cc:1123-1130
#if BUILDFLAG(IS_WIN)
const std::string program_name = electron::Browser::Get()->GetName();
bool app_is_sandboxed =
IsSandboxEnabled(base::CommandLine::ForCurrentProcess());
process_singleton_ = std::make_unique<ProcessSingleton>(
program_name, user_dir, single_instance_additional_data_,
app_is_sandboxed, base::BindRepeating(NotificationCallbackWrapper, cb));
#else
process_singleton_ = std::make_unique<ProcessSingleton>(
user_dir, single_instance_additional_data_,
base::BindRepeating(NotificationCallbackWrapper, cb));
#endif
Windows 需要 program_name 和 app_is_sandboxed,其他平台不需要。
为什么?
program_name:Windows 用命名互斥量(named mutex)实现互斥,互斥量的名字要包含程序名,否则不同应用会撞名。app_is_sandboxed:沙箱进程不能访问某些命名对象,需要换一套实现(用消息而非共享内存)。
而 Linux/macOS 用的是 Unix domain socket:
<userData>/SingletonSocket ← 监听 socket
<userData>/SingletonLock ← 符号链接,指向 "hostname-pid"
<userData>/SingletonCookie ← 随机令牌,防止伪造
三个文件,三个用途:
| 文件 | 用途 |
|---|---|
SingletonLock | 记录"谁持有锁"(主机名 + PID) |
SingletonSocket | 第二个实例连这个 socket 发送命令行 |
SingletonCookie | 验证连接者确实是同一用户(防止其他用户伪造) |
SingletonLock 是一个符号链接而不是普通文件,这个设计很巧妙:符号链接的创建是原子的(symlink() 系统调用),不需要额外的锁;而且读取它就能知道持有者的 PID,如果那个 PID 已经不存在,可以安全地认为锁失效。
2.15.3 三个返回值
electron_api_app.cc:1144-1151
switch (process_singleton_->NotifyOtherProcessOrCreate()) {
case ProcessSingleton::NotifyResult::PROCESS_NONE:
// 我是第一个,拿到锁
if (content::BrowserThread::IsThreadInitialized(content::BrowserThread::IO)) {
process_singleton_->StartWatching();
} else {
watch_singleton_socket_on_ready_ = true;
}
return true;
case ProcessSingleton::NotifyResult::LOCK_ERROR:
case ProcessSingleton::NotifyResult::PROFILE_IN_USE:
case ProcessSingleton::NotifyResult::PROCESS_NOTIFIED: {
ScopedAllowBlockingForElectron allow_blocking;
process_singleton_.reset();
return false;
}
}
四种结果,两种处理:
PROCESS_NONE:没有别的实例,锁创建成功 → 返回true,并开始监听 socket。PROCESS_NOTIFIED:通知了已有实例 → 返回false,本进程应该退出。LOCK_ERROR:锁出错(权限、文件系统异常)→ 返回false。PROFILE_IN_USE:目录被别人占用(可能是另一个用户)→ 返回false。
注意 PROCESS_NONE 里的那个分支:
if (content::BrowserThread::IsThreadInitialized(content::BrowserThread::IO)) {
process_singleton_->StartWatching();
} else {
watch_singleton_socket_on_ready_ = true;
}
如果 IO 线程还没起来,就延后监听。
为什么监听需要 IO 线程?因为 Unix socket 的 accept 是阻塞操作,要投递到 IO 线程。而 requestSingleInstanceLock() 可能在 app.ready 之前被调用(很多应用在 main.js 顶部就调),那时 IO 线程可能还没创建。
这是一个"API 可以在错误的时机被调用"的典型防御。 它没有抛错,而是记了一个标志位,等条件满足再补上。
2.15.4 第二个实例怎么把参数传过去
// 第一个实例
const gotLock = app.requestSingleInstanceLock()
if (!gotLock) {
app.quit()
} else {
app.on('second-instance', (event, argv, workingDirectory, additionalData) => {
// argv 是第二个实例的命令行
if (mainWindow) {
if (mainWindow.isMinimized()) mainWindow.restore()
mainWindow.focus()
}
})
}
argv 是第二个实例的完整命令行。这让"用命令行打开文件"的模式成为可能:
yourapp /path/to/file.txt
第二个实例会把 /path/to/file.txt 通过 socket 传给第一个实例,第一个实例解析 argv 并打开文件。
additionalData 是 requestSingleInstanceLock(data) 传入的第一个参数,经过 blink::CloneableMessage 序列化。它支持传结构化克隆(包括 ArrayBuffer、Map 等)。
注意:additionalData 的序列化格式是 Blink 的 CloneableMessage,不是 Electron 自己的 SerializeV8Value。 两者不兼容,这也是为什么 additionalData 只能传"可结构化克隆"的值,不能传 undefined。
2.15.5 Linux 上的一个特殊处理
electron_api_app.cc:1141
#if BUILDFLAG(IS_LINUX)
// Read the xdg-activation token and set it in the command line for the
// duration of the notification in order to ensure this is propagated to an
// already running electron app instance if it exists.
base::nix::ScopedXdgActivationTokenInjector activation_token_injector(
*base::CommandLine::ForCurrentProcess(), *base::Environment::Create());
#endif
xdg-activation 是 Wayland 时代的一个协议,用来解决"应用 A 想激活应用 B 的窗口"这个问题。
在 X11 时代,任何应用都能抢焦点。Wayland 不允许,必须由"当前有焦点的应用"给一个 token,证明"我确实是被用户操作的"。
这段代码就是把启动时拿到的 token 注入命令行,这样第一个实例收到通知后,能用这个 token 合法地把窗口拉到前面。
这是一个极小的细节,但它决定了"双击图标能不能把窗口带到前面"这个用户体验。
在 Wayland 上不加这个,用户会看到"任务栏图标闪了一下,窗口没出来"——这就是很多人抱怨的"Electron 应用在 Wayland 下不聚焦"问题的根源之一。
2.15.6 一个反模式
// ❌ 错误写法
app.on('ready', () => {
const gotLock = app.requestSingleInstanceLock()
if (!gotLock) app.quit()
// ...
})
放在 ready 里有三个问题:
- 第二个实例已经完成了全部初始化(创建 V8、加载 Node、跑完
main.js),才发现自己是多余的——浪费了 200ms 和 100MB; app.quit()在ready里调用是安全的(RunQuitClosure做了延迟),但用户体验是"闪一下才退出";- 如果有副作用(比如写了配置文件),已经发生了。
正确写法是在 main.js 顶部,做任何有副作用的事之前:
// ✅ 正确写法
if (!app.requestSingleInstanceLock()) {
app.quit()
process.exit(0) // 立刻退出,不等 graceful shutdown
}
process.exit(0) 那行有争议:它会跳过清理。但对"多余的实例"来说,本来就没有需要清理的东西,跳过反而是对的。
2.16 主进程的任务调度:TaskRunner 与 PostTask
进程模型里最容易被低估的东西是"线程"。这一节讲清楚主进程的线程模型在代码里怎么体现。
2.16.1 TaskRunner 是什么
Chromium 的并发模型基于 序列(sequence) 而不是线程:
- 一个
SequencedTaskRunner保证任务按投递顺序执行,但不保证在哪个线程; - 一个
SingleThreadTaskRunner保证在特定线程执行; ThreadPool::GetTaskRunner()返回的 runner 可能跑在任意线程,但同一序列内有序。
为什么要这么设计?因为**"线程"是物理资源,"序列"是逻辑顺序**。用序列表达意图,实现层可以自由调度。
Electron 里最常用的一句:
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, base::BindOnce(&SomeClass::Method, weak_ptr));
GetCurrentDefault() 拿到"当前线程的默认 runner"。在 UI 线程调用它,就能把任务投回 UI 线程。
2.16.2 FROM_HERE 不是装饰
PostTask(FROM_HERE, ...)
FROM_HERE 展开成 base::Location::Current(file, line, function)。它把调用点的位置编码进任务里。
用途:
- 崩溃分析:任务崩溃时,栈里能看到投递点;
- trace:
chrome://tracing里能看到任务的来源; - 调试:
--enable-logging时打印投递位置。
删掉它不会导致编译错误(可以传 base::Location::Current()),但会丢失全部可观测性。这是"零成本可观测性"的典范。
2.16.3 base::Unretained 与 WeakPtr 的选择
这是 Electron 代码里最容易出错的地方。
// 危险
base::BindOnce(&Foo::Bar, base::Unretained(this))
// 安全
base::BindOnce(&Foo::Bar, weak_factory_.GetWeakPtr())
区别:
Unretained假设对象在任务执行时还活着。如果对象提前销毁,任务执行时就是 use-after-free。WeakPtr在对象销毁后自动失效,任务被丢弃。
Electron 的代码里两种都用,判断标准是"生命周期是否确定"。
比如 UtilityProcessWrapper 的构造里用的是 gin::WrapPersistent(weak_factory_.GetWeakCell(...)):
electron_api_utility_process.cc:129-135
auto fail_launch = [&] {
...
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE,
base::BindOnce(&UtilityProcessWrapper::HandleTermination,
gin::WrapPersistent(
weak_factory_.GetWeakCell(allocation_handle)),
kLaunchFailureExitCode));
};
这里用弱引用是对的:启动失败是异步的,如果这个 wrapper 在这期间被 GC(比如 JS 侧丢了引用),任务就不该执行。
而 census 里那行 base::Unretained(Browser::Get()) 是安全的,因为 Browser 是单例,生命周期覆盖整个进程。
2.16.4 一个经典陷阱:PostTask 到已销毁的线程
// 假设在 IO 线程
content::GetUIThreadTaskRunner({})->PostTask(FROM_HERE, cb);
如果 UI 线程已经在关闭流程中(message loop 已停止),这个任务会被丢弃,而 cb 里捕获的资源可能永远不释放。
PostTask 返回 bool,表示是否成功投递。Electron 的代码里很少检查这个返回值,因为大部分场景下"丢弃"是可接受的。
但如果你在写"必须执行"的清理逻辑,就必须检查,或者用 base::SequencedTaskRunner::PostTaskAndReply 的变体。
2.16.5 为什么主进程的 JS 是单线程,但 Chromium 是多线程
这是一个常见的认知混乱。
- JS 引擎(V8)是单线程的:一个 Isolate 在同一时刻只允许一个线程执行 JS。
- Chromium 是多线程的:UI、IO、线程池、GPU(独立进程)。
- 两者通过"投递任务到 UI 线程"连接:任何线程想让 JS 执行,必须
PostTask到 UI 线程,然后由 message loop 调度执行。
这就是为什么:
- IPC 消息到达 IO 线程后,必须
PostTask到 UI 线程才能调到 JS 监听器; setTimeout的回调一定在 UI 线程执行;- 你在 JS 里"等待"一个跨进程结果时,UI 线程并没有阻塞(除非用
sendSync)。
2.16.6 微任务:一条容易被忽略的队列
V8 有一个"微任务队列"(microtask queue),Promise 的 .then 回调就排在这里。
问题:谁来驱动这个队列?
在浏览器里,是 Blink 的 event loop。在 Node 里,是 libuv 的 uv_run 之后。在 Electron 的主进程里,两者都需要——因为主进程既有 Blink 的 message loop(Chromium),又有 Node 的 uv loop。
这就是 MicrotasksRunner 存在的原因(第 1 章提过):
js_env_->CreateMicrotasksRunner();
它的职责是:在 Chromium 的 message loop 每次迭代后,以及 uv loop 每次推进后,都执行一次 PerformCheckpoint()。
如果没有它,Promise 回调可能延迟到下一次事件循环,表现为"await 之后代码执行变慢"。
第 6 章会给出完整的时序分析。
2.17 一个完整的排查案例:进程泄漏
最后用一个真实案例收尾,把所有工具串起来。
2.17.1 症状
一个文档编辑类应用,用户报告:"用两三个小时后,切换文档要等 5 秒,任务管理器显示有 60 多个进程。"
2.17.2 第一步:确认进程数
updates.md:209-215
setInterval(() => {
const metrics = app.getAppMetrics()
console.log('进程数:', metrics.length)
const byType = {}
for (const m of metrics) byType[m.type] = (byType[m.type] || 0) + 1
console.log(byType)
}, 60000)
输出:
进程数: 63
{ Browser: 1, Tab: 58, GPU: 1, Utility: 3 }
58 个 Tab 进程。 而用户只打开了 3 个文档。
2.17.3 第二步:找出这些 Tab 是谁
const { webContents } = require('electron')
const list = webContents.getAllWebContents().map(wc => ({
id: wc.id,
pid: wc.getOSProcessId(),
url: wc.getURL().slice(0, 80),
destroyed: wc.isDestroyed()
}))
console.table(list)
结果:
id pid url destroyed
1 1040 file:///app/index.html false
7 1051 file:///app/index.html false
...
62 2890 about:blank false
大部分是 about:blank。
2.17.4 第三步:定位代码
搜索 new BrowserWindow 的调用点,找到"导出预览"功能:
function showPreview(content) {
const win = new BrowserWindow({ show: false, width: 800, height: 600 })
win.loadURL('about:blank')
win.webContents.once('did-finish-load', () => {
win.webContents.insertCSS(content)
})
// ❌ 没有关闭逻辑
}
每次调用都创建一个新窗口,从不销毁。
2.17.5 第四步:修复
// 方案 A:复用单例
let previewWin = null
function showPreview(content) {
if (!previewWin || previewWin.isDestroyed()) {
previewWin = new BrowserWindow({ show: false })
}
previewWin.webContents.insertCSS(content)
}
// 方案 B:用完立刻销毁
function showPreview(content) {
const win = new BrowserWindow({ show: false })
win.once('ready-to-show', () => {
win.webContents.insertCSS(content)
// 用完销毁
setTimeout(() => win.destroy(), 100)
})
}
注意 destroy() 与 close() 的区别:
close()触发close事件,可以被beforeunload阻止,然后才是销毁;destroy()立即销毁,不触发close,不询问页面。
对"程序内部创建的临时窗口",用 destroy() 更合适——你不希望页面的 beforeunload 阻止你的清理逻辑。
2.17.6 第五步:加防护
修完代码还不够,要加一道保险:
const MAX_WINDOWS = 10
const all = BrowserWindow.getAllWindows()
if (all.length > MAX_WINDOWS) {
// 找到最久未使用的,销毁
const oldest = all
.filter(w => w !== mainWindow)
.sort((a, b) => a.getLastUsedTime() - b.getLastUsedTime())[0]
oldest?.destroy()
console.warn('超过窗口上限,销毁了最旧的窗口')
}
getLastUsedTime() 不在公开 API 里(它是内部能力),实际实现可以用"最后一次 focus 的时间"自己记录。
2.17.7 教训
- 每个
new BrowserWindow都必须有对应的销毁路径。 这不是建议,是纪律。 hide()不是销毁。 它只是不可见,进程和内存都还在。webContents.getAllWebContents()是最快的体检工具。 数量异常就是泄漏。about:blank是泄漏的高发地。 因为它的加载永远完成,不会报错,很容易被遗忘。
2.18 两个容易被忽略的细节:句柄继承与调试器
2.18.1 句柄继承:为什么子进程会"占着"父进程的资源
在 POSIX 系统上,fork() 会复制父进程的整个文件描述符表。这意味着:如果你在父进程里打开了一个文件,然后 fork 一个子进程,子进程也持有那个 fd。
后果是:你关闭了文件,但文件仍然"被打开"(因为子进程还持有引用),磁盘上的空间不释放,或者 socket 连接不断开。
Electron 在 utilityProcess 的实现里对此有明确处理:
electron_api_utility_process.cc:177-181
#elif BUILDFLAG(IS_POSIX)
int pipe_fd[2];
if (HANDLE_EINTR(pipe(pipe_fd)) < 0) { ... }
if (io_handle == IOHandle::STDOUT) {
fds_to_remap.emplace_back(pipe_fd[1], STDOUT_FILENO);
stdout_read_fd_ = pipe_fd[0];
}
注意 fds_to_remap 只放需要传给子进程的 fd(管道的写端),读端留在父进程。
Chromium 的 base::LaunchProcess 在 POSIX 上会做一件事:把不在 fds_to_remap 里的 fd 全部关闭(通过 FD_CLOEXEC 或显式 close)。这是"最小权限"原则的体现——子进程只拿到它需要的句柄。
Windows 上的对应机制是"句柄继承标志"(HANDLE_FLAG_INHERIT)。默认情况下,CreateProcess 只继承被标记为可继承的句柄。
代码里对 Windows 的注释很详细:
// Ideally we would create with SECURITY_ATTRIBUTES.bInheritHandles
// set to TRUE so that the write handle can be duplicated into the
// child process for use, ... But we don't do it here
// since base::Launch already takes of setting the
// inherit attribute when configuring `base::LaunchOptions::handles_to_inherit`
这段话说明了一个分层:Electron 只负责"创建管道","如何让子进程拿到它"由 Chromium 的 base::LaunchProcess 负责。
这种"各管一层"的设计在 Chromium 里很常见,也是它难以阅读的原因之一——你必须在两个仓库之间跳。
实践含义:如果你的应用在 fork 子进程后出现"文件删不掉"、"端口占用"、"socket 不关闭",先查是不是子进程继承了不该继承的 fd。
诊断命令(Linux):
ls -l /proc/<child_pid>/fd
如果看到一堆你不认识的 fd,就是继承问题。
2.18.2 附加调试器到渲染进程
主进程可以直接用 --inspect 调试:
electron --inspect=9229 .
但渲染进程不能。原因:渲染进程的启动参数由主进程控制,你不能直接在命令行加 --inspect。
三种方法:
方法 1:--inspect-brk + 端口分配
electron --inspect-brk .
这会让主进程在第一行暂停。要让渲染进程也暂停,需要:
application-debugging.md:19-20
// 主进程里
win.webContents.openDevTools()
// 或
win.webContents.debugger.attach('1.3')
方法 2:用 webContents.debugger(推荐)
const dbg = win.webContents.debugger
dbg.attach('1.3')
dbg.on('message', (event, method, params) => {
console.log(method, params)
})
dbg.sendCommand('Runtime.evaluate', { expression: '1+1' })
这是"在应用内部驱动 CDP(Chrome DevTools Protocol)",可以脚本化。
方法 3:远程调试端口
electron --remote-debugging-port=9222 .
然后用 Chrome 打开 http://localhost:9222,能看到所有可调试的目标(包括渲染进程、Service Worker)。
注意安全风险:--remote-debugging-port 会让任何本地进程都能控制你的应用。生产环境必须关掉,或者只监听 127.0.0.1 且加认证。
Electron 的 fuse EnableNodeCliInspectArguments 就是用来在打包时禁掉 --inspect 的,防止攻击者用调试器注入代码。
2.18.3 崩溃回退的判定逻辑
GPU 进程崩溃后,Chromium 不是简单地"重启",而是有一套判定:
GPU 崩溃 1 次 → 重启
GPU 崩溃 2 次(短时间内)→ 禁用部分特性(比如 GPU 光栅化)
GPU 崩溃 3 次 → 完全回退到软件渲染(SwiftShader)
这个逻辑在 Chromium 的 GpuDataManagerImpl 里。Electron 没有改它,但你可以通过 app.getGPUFeatureStatus() 查询当前状态:
console.log(app.getGPUFeatureStatus())
// { '2d_canvas': 'enabled', gpu_compositing: 'enabled', ... }
如果看到 software_only 或 disabled_software,说明已经回退。
这个 API 是排查"为什么我的动画很卡"的第一个工具。 很多用户报"卡",实际是 GPU 被禁用了(驱动问题、远程桌面、虚拟机)。
2.18.4 进程模型速查卡
最后给一张可以贴在显示器旁边的表:
┌──────────────────────────────────────────────────────────────┐
│ 我要做的事 → 写在哪 │
├──────────────────────────────────────────────────────────────┤
│ 创建窗口/菜单/托盘 → 主进程(BrowserWindow/Tray) │
│ 读写本地文件(少量) → 主进程(fs) │
│ 读写本地文件(大量/流) → utility process │
│ CPU 密集计算 → utility process / worker │
│ DOM 操作 → 渲染进程 │
│ 调系统 API(对话框/通知) → 主进程 │
│ 长连接的 WebSocket → 主进程(net)或渲染进程 │
│ 数据库 → utility process │
│ 需要在窗口关闭后继续跑的 → 主进程或 utility │
│ 需要隔离不可信代码 → 渲染进程(sandbox: true) │
│ 需要原生模块(.node) → 主进程(不能在沙箱) │
└──────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────┐
│ 现象 → 先查什么 │
├──────────────────────────────────────────────────────────────┤
│ 白屏 → GPU 崩溃 / 渲染进程崩溃 │
│ 卡顿 → 主进程阻塞 / GPU 回退软件渲染 │
│ 内存持续上涨 → WebContents 泄漏 / 监听器未解绑│
│ 进程数持续上涨 → new BrowserWindow 未销毁 │
│ 双击图标没反应 → 单实例锁 / 窗口未 focus │
│ 文件删不掉 → 子进程继承了 fd │
│ 打包后 fork 失败 → 用 utilityProcess 替代 │
└──────────────────────────────────────────────────────────────┘
2.19 本章涉及的源码文件
读源码最怕"不知道从哪进"。这一节把本章引用的全部文件列出来,注明作用与阅读优先级。
必读(四个)
| 文件 | 行数 | 作用 | 读什么 |
|---|---|---|---|
process_util.cc | 48 | 进程身份判定 | 全文 |
electron_main_delegate.cc:177 | 约 1000 | 进程入口与平台分叉 | BasicStartupComplete、PreSandboxStartup |
electron_api_utility_process.cc:601 | 约 800 | utility process 全部逻辑 | Create、构造函数、ShutdownAll |
api.mojom | 约 200 | 跨进程接口定义 | 五个 interface |
应读(六个)
| 文件 | 作用 |
|---|---|
electron_browser_client.cc | 2380 行,渲染进程创建/退出、webPreferences、命令行 |
electron_gpu_client.cc:17 | GPU 进程策略(很短,只有 PreCreateMessageLoop) |
node_service.mojom | utility process 的 Node 服务接口 |
electron_api_service_worker_main.cc | Service Worker 的主进程代理 |
osr_web_contents_view.cc | 离屏渲染的视图替代品 |
lib/browser/init.ts | 主进程 JS 启动脚本(121 行) |
参考(用到再查)
shell/browser/electron_api_ipc_handler_impl.cc IPC 的 C++ 落地
shell/browser/electron_api_sw_ipc_handler_impl.cc Service Worker 的 IPC
shell/browser/message_port.cc MessagePort 纠缠
shell/browser/electron_navigation_throttle.cc 导航拦截(进程交换相关)
shell/common/process_util.h 上面那个 .cc 的头
docs/tutorial/process-model.md 官方文档,写得不错
docs/tutorial/sandbox.md 沙箱文档
一个阅读顺序建议
1. process_util.cc (5 分钟,建立"身份"概念)
2. api.mojom (15 分钟,看跨进程能力的全貌)
3. electron_main_delegate.cc 的 PreSandboxStartup
(20 分钟,看平台差异如何体现)
4. electron_api_utility_process.cc 的 Create + 构造函数
(40 分钟,看一个完整的"创建进程"流程)
5. electron_browser_client.cc 的 AppendExtraCommandLineSwitches
(20 分钟,看安全校验与开关传递)
6. docs/tutorial/process-model.md (15 分钟,对照官方表述)
两个小时后,你对"Electron 的进程"会有一个可以自洽解释的模型。
2.20 术语对照
本章出现的术语,与 Chromium/Electron 社区的常见叫法对照:
| 本书 | Chromium 代码里 | JS API 里 |
|---|---|---|
| 主进程 | browser process | process.type === 'browser' |
| 渲染进程 | renderer process | process.type === 'renderer' |
| GPU 进程 | gpu process | process.type === 'gpu' |
| utility process | service process / utility process | process.type === 'utility' |
| 渲染帧 | RenderFrameHost / RenderFrame | webFrameMain |
| 站点实例 | SiteInstance | 无直接对应 |
| 浏览器上下文 | BrowserContext | Session |
| 渲染进程宿主 | RenderProcessHost | webContents.getOSProcessId() 间接 |
| 子进程启动器 | ChildProcessLauncher | 无 |
| 进程沙箱 | sandbox::policy | webPreferences.sandbox |
| 隔离世界 | isolated world | webFrame.executeJavaScriptInIsolatedWorld |
| 预加载脚本 | preload script | webPreferences.preload |
注意"浏览器上下文 → Session"这一行。 这是最容易混淆的映射:Chromium 叫 BrowserContext,Electron 的 JS API 叫 Session,而 W3C 规范里的 "browsing context" 是完全另一个概念(frame 树)。
2.21 一个思想实验:如果只有一个进程
理解一个设计的最好方法,是想象去掉它会怎样。
假设 Electron 只有一个进程:UI、Node、页面、网络、合成全在一个进程里。会发生什么?
2.21.1 好处(很少,但真实)
第一,IPC 消失。 所有调用都是本地函数调用,ipcRenderer.invoke 变成直接函数返回,延迟从 0.2ms 降到 0.002ms。
第二,内存省一大截。 只有一个 V8 Isolate、一份代码段、一份堆。一个应用的常驻内存可能从 200MB 降到 80MB。
第三,调试简单。 一个进程,一个调试器,一条栈。
2.21.2 代价(很多,且致命)
第一,页面里的一行 while(true) 会冻结整个应用。
因为 UI 线程和 JS 线程是同一条。这在单进程浏览器时代是常态,用户学会了"不要打开那个网站"。
第二,任何一次崩溃都会带走全部状态。
一个第三方库的 segfault、一次显存溢出、一个野指针——全部未保存的文档一起消失。
第三,安全模型崩塌。
页面里的脚本可以直接读 process.env、读文件、读其他窗口的内存。任何 XSS 都变成远程代码执行。
第四,无法利用多核。
JS 是单线程的,单进程意味着整个应用只能用一核。渲染、解码、计算全挤在一起。
2.21.3 历史给出的答案
Chrome 在 2008 年选了多进程,代价是内存。当时的评论家说"这太浪费了"。十七年后,所有主流浏览器都是多进程。
原因很简单:崩溃和安全问题是"必然会发生"的,而内存是"可以买的"。
Electron 继承了这个选择。它把"必然会发生"的那部分(页面崩溃、恶意脚本)隔离开,把成本(内存)转嫁给用户。
这个交换在今天依然成立:一台 8GB 的机器跑 200MB 的应用很正常,但没有人能接受"浏览器崩了,我的 20 个标签页全没了"。
2.21.4 但边界在移动
值得注意的是,"多进程"不是教条。近年出现了两个反向趋势:
趋势一:进程复用。 Chromium 的 SiteInstance 机制让同站点的多个页面共享进程,减少了进程数。Electron 继承了这个机制。
趋势二:进程内隔离。 V8 的 Isolate、Blink 的 Agent Cluster,让"同一进程内的多个上下文"也能有一定隔离。这是为低内存设备准备的。
Electron 的定位是桌面,桌面不缺内存,所以它依然选择"进程优先"。但在嵌入式场景(比如某些 IoT 设备上的 Electron),你可能会看到 --single-process 被真正使用——代价是接受所有风险。
理解这个权衡,比记住"Electron 是多进程"这个结论重要得多。
2.22 本章小结:四条结论
结论一:进程身份由命令行决定,且只在启动时计算一次
--type 是唯一的判据,static 缓存让它不可变。IsBrowserProcess() 判的是"类型为空",因此 ELECTRON_RUN_AS_NODE 的进程也会被误判——IsRunningAsNode() 就是为修正这个歧义而存在的。
结论二:四类进程各有明确的能力边界
| 进程 | Node | DOM | 沙箱 | 崩溃影响 |
|---|---|---|---|---|
| browser | ✅ | ❌ | ❌ | 应用退出 |
| renderer | 可选 | ✅ | 可选 | 白屏,可恢复 |
| GPU | ❌ | ❌ | 部分 | 花屏,自动重启 |
| utility | ✅ | ❌ | ❌ | 可恢复 |
这个表格是架构决策的起点。任何一个"这个功能放哪"的问题,都能用它回答。
结论三:通信必须经过 mojo,意味着三次转换
JS 值 → SerializedValue 字节流 → mojo 消息 → 反序列化。每一次都是成本,也每一次都是安全边界。
api.mojom:52 里的五个接口(ElectronFrame、ElectronRenderer、ElectronApiIPC、ElectronAutofillAgent、ElectronAutofillDriver)覆盖了 Electron 的全部跨进程能力。想知道某个 API 怎么跨进程,先看它对应哪个 mojom 方法。
结论零:进程不是"性能优化",是"故障隔离"
这一条应该放在最前面,但放在最后说更容易被记住。
很多人把多进程理解为"为了并行"。这个理解是错的:Electron 的进程划分几乎不带来并行收益(渲染进程本来就是单线程 JS),它带来的是故障隔离。
一个渲染进程崩了,主进程还在,其他窗口还在,未保存的数据还在主进程里。一个 GPU 进程崩了,页面还在,只是暂时白屏。
如果哪天你为了"省内存"想把功能合并到一个进程里,请先回答:这个功能崩了,用户会损失什么? 如果答案不是"什么都不会损失",那就不要合并。
结论四:崩溃是常态,不是异常
RenderProcessWillLaunch 里那行 RemoveObserver 的注释("in case the host is reused after a crash")说明了官方态度:进程会崩,host 会复用,代码必须为此设计。
应用层的对应要求:每个渲染进程都要有崩溃处理,每个长任务都要能重试,每个状态都要能重建。
2.23 练习题
1. 数清你的进程。
写一个脚本,在应用启动 5 秒后打印 app.getAppMetrics(),并对每个渲染进程打印它的 URL。然后回答:为什么渲染进程数和你打开的窗口数不一样?
2. 验证 static 缓存。
在主进程里执行:
const { app } = require('electron')
console.log(process.type) // 'browser'
app.commandLine.appendSwitch('type', 'renderer')
console.log(process.type) // 还是 'browser'?
解释为什么第二次打印不是 'renderer'。提示:process.type 是 C++ 侧的属性,而 IsBrowserProcess() 是另一套缓存。
3. 找一条 IPC 的完整路径。
选 webContents.executeJavaScript,从 JS 调用开始,找到它对应的 mojom 方法、C++ handler、以及在渲染进程侧的执行入口。画出调用链。
4. 观察一次崩溃。
在渲染进程里执行 process.crash()(需要 nodeIntegration),观察:
- 主进程收到什么事件?
details.reason是什么?- 窗口变成什么样?
- 如果有
render-process-gone监听器,它什么时候被调用?
5. 比较三种子进程方案。
写三个最小程序,分别用 child_process.fork、worker_threads、utilityProcess.fork 计算 fib(35)。记录:
- 启动时间;
- 主进程是否卡顿;
- 崩溃后主进程是否能感知;
- 内存占用。
6. 验证 utility process 的 env 语义。
const child = utilityProcess.fork(script, [], { env: { FOO: 'bar' } })
在子进程里打印 process.env.PATH。它存在吗?为什么?如果想让 PATH 也保留,应该怎么写?
7. 读一段 mojom。
打开 api.mojom:59,找到 ExecuteJavaScript 的返回类型,解释为什么需要 (bool, SerializedValue, string) 三态而不是一个可空值。
一个补充说明:为什么本章没有讲 "single process mode" 的实现
--single-process 这个开关确实存在,它在 Chromium 里叫 "in-process renderer":渲染进程的代码被编译进浏览器进程,RenderProcessHost 退化成一个假实现,IPC 变成直接函数调用。
Electron 保留了这条代码路径(因为它来自 content 层),但从未测试、从未支持、明确不推荐。它的存在价值只有一个:当用户报告"只在某个环境下出现"的诡异问题时,用它来验证"是不是进程间通信导致的"。
如果用了它之后问题消失,说明问题在 IPC 或进程边界;如果问题依旧,说明在渲染逻辑本身。这是一个诊断工具,不是一个部署选项。
本章之所以不展开它,是因为展开会误导——让你以为它是一个可选架构。它不是。
2.24 下一章
进程模型讲完了"运行时"。下一章跳到另一个极端:构建时。
为什么编译一个 Electron 需要 380 个补丁?e build 背后跑的是什么?filenames.gni 那个 46KB 的文件在管什么?为什么改一个 .ts 文件也要重新编译 C++?
第 3 章会回答这些问题。读它之前,请先记住本章的一句话:
Electron 的进程模型决定了它必须有四套构建目标,而每一套都依赖不同的上游代码。
具体来说,第 3 章会拆开这些:
BUILD.gn的 72KB 在定义什么:electron_js2c、electron_lib、electron三个核心目标的关系;filenames.gni的 46KB 为什么必须存在:为什么不能靠 glob 自动收集源文件;bundle.mjs与js2c.py的两级转换:TS 如何变成 C++ 字符串;all.gn:5里那些参数的连锁反应:改一个node_module_version会影响什么;chromium_src/这个"影子目录":它如何在不改上游的前提下替换 Chromium 的文件;- 增量编译的边界:为什么改一行 TS 也会触发 C++ 重编。
这些是"能不能改得动 Electron"的分水岭。很多人能读懂运行时逻辑,却卡在"编译不过"上——差别就在这里。
最后提醒一句:本章所有关于平台差异的描述,都以 Electron 45.2.3 的代码为准。Chromium 每个大版本都会调整进程模型(比如新的 AgentSchedulingGroup、SiteInstanceGroup),下次升级时这些细节可能需要重新核对。
这一条不是免责声明,而是一个提示:读源码时永远要带着版本号,否则你记住的"事实"会在下次升级时悄悄失效。
2.25 本章源码落点索引
下列位置全部来自本仓库源码树,按实现层归集;每个
路径:行号指向该文件中与本章论述对应的声明或实现行,可逐条复核。
- 浏览器进程 C++ 层:
electron_api_utility_process.h:34 electron_api_web_contents.cc:249 electron_api_web_contents.h:61 electron_api_web_contents_impl.cc:19 electron_api_web_contents_mac.mm:16 electron_api_web_contents_view.cc:38 electron_api_web_contents_view.h:17 child_web_contents_tracker.cc:13 -
child_web_contents_tracker.h:16 electron_web_contents_utility_handler_impl.cc:23 electron_web_contents_utility_handler_impl.h:15 extended_web_contents_observer.h:13 osr_web_contents_view.h:20 osr_web_contents_view_mac.mm:9 web_contents_permission_helper.cc:35 web_contents_permission_helper.h:20 -
web_contents_preferences.cc:41 web_contents_zoom_controller.cc:27 web_contents_zoom_controller.h:19 web_contents_zoom_observer.h:15 electron_extension_web_contents_observer.cc:10 electron_extension_web_contents_observer.h:14 electron_extensions_browser_client.cc:58 electron_extensions_browser_client.h:20 -
file_system_access_web_contents_helper.cc:11 file_system_access_web_contents_helper.h:11 inspectable_web_contents.cc:111 inspectable_web_contents.h:28 - shell 其余实现:
node_service.cc:44 node_service.h:31 node_bindings_linux.cc:11 node_bindings_linux.h:12 node_bindings_mac.cc:15 node_bindings_mac.h:12 node_bindings_win.cc:13 node_bindings_win.h:12 -
process_util.h:12 web_contents_utility.mojom:8 - API 文档与类型:
utility-process.md:7 web-contents-view.md:5 web-contents.md:5 - JS 门面与运行时:
utility-process.ts:5 web-contents.ts:20