child_process.fork(modulePath[, args][, options])
modulePath
<string> | <URL> 要在子进程中运行的模块。args
<string[]> 字符串参数列表。options
<Object>cwd
<string> | <URL> 子进程的当前工作目录。detached
<boolean> 准备子进程独立于其父进程运行。 具体行为取决于平台,参见options.detached
。env
<Object> 环境变量键值对。 默认值:process.env
。execPath
<string> 用于创建子进程的可执行文件。execArgv
<string[]> 传给可执行文件的字符串参数列表。 默认值:process.execArgv
。gid
<number> 设置进程的群组标识(参见setgid(2)
)。serialization
<string> 指定用于在进程之间发送消息的序列化类型。 可能的值为'json'
和'advanced'
。 有关更多详细信息,请参阅高级序列化。 默认值:'json'
。signal
<AbortSignal> 允许使用中止信号关闭子进程。killSignal
<string> | <integer> 当衍生的进程将被超时或中止信号杀死时要使用的信号值。 默认值:'SIGTERM'
。silent
<boolean> 如果为true
,则子进程的标准输入、标准输出和标准错误将通过管道传输到父进程,否则它们将从父进程继承,有关详细信息,请参阅child_process.spawn()
的stdio
的'pipe'
和'inherit'
选项。 默认值:false
。stdio
<Array> | <string> 参见child_process.spawn()
的stdio
。 提供此选项时,它会覆盖silent
。 如果使用数组变体,则它必须恰好包含一个值为'ipc'
的条目,否则将抛出错误。 例如[0, 1, 2, 'ipc']
。uid
<number> 设置进程的用户标识(参见setuid(2)
)。windowsVerbatimArguments
<boolean> 在 Windows 上不为参数加上引号或转义。 在 Unix 上被忽略。 默认值:false
。timeout
<number> 允许进程运行的最长时间(以毫秒为单位)。 默认值:undefined
。
- 返回: <ChildProcess>
child_process.fork()
方法是 child_process.spawn()
的特例,专门用于衍生新的 Node.js 进程。
与 child_process.spawn()
一样,返回 ChildProcess
对象。
返回的 ChildProcess
将有额外的内置通信通道,允许消息在父进程和子进程之间来回传递。
详见 subprocess.send()
。
请记住,衍生的 Node.js 子进程独立于父进程,除了两者之间建立的 IPC 通信通道。 每个进程都有自己的内存,具有自己的 V8 实例。 由于需要额外的资源分配,不建议衍生大量子 Node.js 进程。
默认情况下,child_process.fork()
将使用父进程的 process.execPath
衍生新的 Node.js 实例。
options
对象中的 execPath
属性允许使用替代的执行路径。
使用自定义 execPath
启动的 Node.js 进程将使用在子进程上使用环境变量 NODE_CHANNEL_FD
标识的文件描述符与父进程通信。
与 fork(2)
POSIX 系统调用不同,child_process.fork()
不克隆当前进程。
child_process.fork()
不支持 child_process.spawn()
中可用的 shell
选项,如果设置将被忽略。
如果启用了 signal
选项,则在相应的 AbortController
上调用 .abort()
与在子进程上调用 .kill()
类似,只是传给回调的错误将是 AbortError
:
if (process.argv[2] === 'child') {
setTimeout(() => {
console.log(`Hello from ${process.argv[2]}!`);
}, 1_000);
} else {
const { fork } = require('node:child_process');
const controller = new AbortController();
const { signal } = controller;
const child = fork(__filename, ['child'], { signal });
child.on('error', (err) => {
// 如果控制器中止,则这将在 err 为 AbortError 的情况下被调用
});
controller.abort(); // 停止子进程
}
modulePath
<string> | <URL> The module to run in the child.args
<string[]> List of string arguments.options
<Object>cwd
<string> | <URL> Current working directory of the child process.detached
<boolean> Prepare child to run independently of its parent process. Specific behavior depends on the platform, seeoptions.detached
).env
<Object> Environment key-value pairs. Default:process.env
.execPath
<string> Executable used to create the child process.execArgv
<string[]> List of string arguments passed to the executable. Default:process.execArgv
.gid
<number> Sets the group identity of the process (seesetgid(2)
).serialization
<string> Specify the kind of serialization used for sending messages between processes. Possible values are'json'
and'advanced'
. See Advanced serialization for more details. Default:'json'
.signal
<AbortSignal> Allows closing the child process using an AbortSignal.killSignal
<string> | <integer> The signal value to be used when the spawned process will be killed by timeout or abort signal. Default:'SIGTERM'
.silent
<boolean> Iftrue
, stdin, stdout, and stderr of the child will be piped to the parent, otherwise they will be inherited from the parent, see the'pipe'
and'inherit'
options forchild_process.spawn()
'sstdio
for more details. Default:false
.stdio
<Array> | <string> Seechild_process.spawn()
'sstdio
. When this option is provided, it overridessilent
. If the array variant is used, it must contain exactly one item with value'ipc'
or an error will be thrown. For instance[0, 1, 2, 'ipc']
.uid
<number> Sets the user identity of the process (seesetuid(2)
).windowsVerbatimArguments
<boolean> No quoting or escaping of arguments is done on Windows. Ignored on Unix. Default:false
.timeout
<number> In milliseconds the maximum amount of time the process is allowed to run. Default:undefined
.
- Returns: <ChildProcess>
The child_process.fork()
method is a special case of
child_process.spawn()
used specifically to spawn new Node.js processes.
Like child_process.spawn()
, a ChildProcess
object is returned. The
returned ChildProcess
will have an additional communication channel
built-in that allows messages to be passed back and forth between the parent and
child. See subprocess.send()
for details.
Keep in mind that spawned Node.js child processes are independent of the parent with exception of the IPC communication channel that is established between the two. Each process has its own memory, with their own V8 instances. Because of the additional resource allocations required, spawning a large number of child Node.js processes is not recommended.
By default, child_process.fork()
will spawn new Node.js instances using the
process.execPath
of the parent process. The execPath
property in the
options
object allows for an alternative execution path to be used.
Node.js processes launched with a custom execPath
will communicate with the
parent process using the file descriptor (fd) identified using the
environment variable NODE_CHANNEL_FD
on the child process.
Unlike the fork(2)
POSIX system call, child_process.fork()
does not clone the
current process.
The shell
option available in child_process.spawn()
is not supported by
child_process.fork()
and will be ignored if set.
If the signal
option is enabled, calling .abort()
on the corresponding
AbortController
is similar to calling .kill()
on the child process except
the error passed to the callback will be an AbortError
:
if (process.argv[2] === 'child') {
setTimeout(() => {
console.log(`Hello from ${process.argv[2]}!`);
}, 1_000);
} else {
const { fork } = require('node:child_process');
const controller = new AbortController();
const { signal } = controller;
const child = fork(__filename, ['child'], { signal });
child.on('error', (err) => {
// This will be called with err being an AbortError if the controller aborts
});
controller.abort(); // Stops the child process
}