JS `Child Process` 高级：`spawn` `detached`, `stdio` 重定向与 IPC 通信

各位观众老爷，晚上好！今天咱们不开车，聊点正经的——Node.js 的 child_process 模块里那些让人既爱又恨的家伙：spawn、detached、stdio 重定向，以及 IPC 通信。准备好了吗？坐稳扶好，发车！

一、spawn：子进程的诞生

首先，咱们要了解的是 spawn。这家伙是 child_process 模块里最基础、也最强大的创建子进程的方法。它就像个辛勤的媒婆，负责牵线搭桥，把你的 Node.js 进程和操作系统里的其他程序（比如 Python 脚本、Shell 命令、甚至是另一个 Node.js 进程）联系起来。

spawn 函数的语法如下：

const { spawn } = require('child_process');

const child = spawn(command, [args], [options]);

command: 要执行的命令，必须是字符串。
args: 传递给命令的参数，是一个字符串数组，可选项。
options: 配置选项，是一个对象，也是可选项。

举个栗子，咱们用 spawn 来执行一个简单的 ls -l 命令：

const { spawn } = require('child_process');

const ls = spawn('ls', ['-l', '/usr/bin']); //假设/usr/bin存在

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

ls.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});

ls.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

这段代码做了什么？

引入 child_process 模块的 spawn 方法。
使用 spawn('ls', ['-l', '/usr/bin']) 创建一个子进程来执行 ls -l /usr/bin 命令。
监听子进程的 stdout (标准输出)、stderr (标准错误)，并把它们打印到控制台。
监听子进程的 close 事件，当子进程退出时，打印退出码。

二、detached：放飞自我，让子进程独立生存

有时候，我们希望启动一个子进程，但并不想让它和父进程“藕断丝连”，父进程退出后，子进程还能继续运行。这时候，detached 选项就派上用场了。

const { spawn } = require('child_process');

const child = spawn('node', ['long-running-script.js'], {
  detached: true,
  stdio: 'ignore' //重要：忽略父进程的stdio
});

child.unref(); // 重要：允许父进程退出

console.log('Parent process exiting...');

这段代码的关键在于：

detached: true: 告诉 Node.js，这个子进程要和父进程分离。
stdio: 'ignore': 非常重要！ 忽略父进程的标准输入、输出和错误。如果不忽略，父进程退出时，子进程可能会收到 SIGPIPE 信号而崩溃。
child.unref(): 允许父进程退出，即使子进程还在运行。如果不调用 unref()，父进程会一直等待子进程结束。

解释一下为什么 stdio: 'ignore' 如此重要。默认情况下，子进程会继承父进程的标准输入、输出和错误流。当父进程退出时，这些流会被关闭。如果子进程还在尝试写入这些流，就会收到 SIGPIPE 信号，导致程序崩溃。通过设置 stdio: 'ignore'，我们告诉子进程，不要使用父进程的流，而是使用操作系统默认的流。

三、stdio 重定向：子进程的输入输出你做主

stdio (Standard Input/Output) 是进程与外界交互的通道。一个进程通常有三个标准流：

stdin (标准输入): 进程从这里读取数据。
stdout (标准输出): 进程向这里写入数据。
stderr (标准错误): 进程向这里写入错误信息。

spawn 函数的 options 对象允许我们控制子进程的 stdio，实现输入输出重定向。stdio 选项可以是一个数组，也可以是一个字符串。

3.1 stdio 数组

stdio 数组的每个元素都对应一个标准流，顺序是 [stdin, stdout, stderr]。每个元素可以是以下值之一：

'pipe': 创建一个管道，父进程可以通过 child.stdin、child.stdout、child.stderr 访问子进程的流。
'ignore': 忽略这个流。
'inherit': 让子进程继承父进程的流。
文件描述符 (整数): 将流重定向到指定的文件描述符。
Stream 对象: 将流重定向到指定的 Stream 对象。

举个栗子，把子进程的标准输出重定向到一个文件：

const { spawn } = require('child_process');
const fs = require('fs');

const out = fs.openSync('./out.log', 'a');
const err = fs.openSync('./out.log', 'a');

const child = spawn('ls', ['-l'], {
  stdio: ['ignore', out, err] // 忽略 stdin, stdout 和 stderr 都重定向到 out.log
});

// 注意：不要监听 stdout 和 stderr 事件，因为它们已经被重定向了。

child.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

3.2 stdio 字符串

stdio 选项也可以是一个字符串，它相当于 stdio 数组的简化写法。常用的字符串值有：

'pipe': 相当于 ['pipe', 'pipe', 'pipe']。
'ignore': 相当于 ['ignore', 'ignore', 'ignore']。
'inherit': 相当于 ['inherit', 'inherit', 'inherit']。

表格总结 stdio 选项：

值	类型	描述
`'pipe'`	字符串/数组元素	创建管道，父进程可以通过 `child.stdin`、`child.stdout`、`child.stderr` 访问子进程的流。
`'ignore'`	字符串/数组元素	忽略这个流。
`'inherit'`	字符串/数组元素	让子进程继承父进程的流。
文件描述符	数组元素	将流重定向到指定的文件描述符。
Stream 对象	数组元素	将流重定向到指定的 Stream 对象。

四、IPC 通信：父子进程心连心

IPC (Inter-Process Communication) 是指进程间通信。child_process 模块提供了一种简单的方式来实现父进程和子进程之间的双向通信：通过 stdio 的管道。

当你在 stdio 选项中设置了 'pipe'，Node.js 会自动创建一个 IPC 通道。你可以使用 child.send() 方法从父进程向子进程发送消息，子进程可以通过监听 process.on('message', ...) 事件来接收消息。反之亦然。

举个栗子：

父进程 (parent.js):

const { spawn } = require('child_process');

const child = spawn('node', ['child.js'], {
  stdio: ['pipe', 'pipe', 'pipe', 'ipc'] // 启用 IPC 通道
});

child.on('message', (message) => {
  console.log(`Parent received: ${message}`);
});

child.stdout.on('data', (data) => {
  console.log(`Child stdout: ${data}`);
});

child.stderr.on('data', (data) => {
  console.error(`Child stderr: ${data}`);
});

child.send('Hello from parent!');

setTimeout(() => {
  child.send({type: 'shutdown'}); //示例发送一个对象
}, 3000);

child.on('exit', (code) => {
  console.log(`Child process exited with code ${code}`);
});

子进程 (child.js):

process.on('message', (message) => {
  console.log(`Child received: ${message}`);

  if (typeof message === 'object' && message.type === 'shutdown') {
    console.log('Child process shutting down...');
    process.exit(0);
  }

  process.send('Hello from child!');
});

console.log("Child process started");

// 模拟一些耗时操作，持续输出到 stdout
setInterval(() => {
    console.log("Child process is still running...");
}, 1000);

这段代码做了什么？

父进程使用 spawn 创建一个子进程，并设置 stdio 包含 'ipc'，启用 IPC 通道。
父进程监听子进程的 message 事件，接收子进程发来的消息。
父进程使用 child.send() 方法向子进程发送消息。
子进程监听 process.on('message', ...) 事件，接收父进程发来的消息。
子进程使用 process.send() 方法向父进程发送消息。

IPC 通信的注意事项：

IPC 通道只能用于父进程和子进程之间的通信。
你可以发送任何可以被 JSON 序列化的数据，包括对象、数组、字符串、数字、布尔值和 null。
如果发送的是一个 Buffer 对象，它会被复制到目标进程。
IPC 通道是双向的，父进程和子进程都可以发送和接收消息。

五、错误处理

在使用 child_process 模块时，错误处理非常重要。以下是一些常见的错误情况和处理方法：

命令不存在: 如果 spawn 函数指定的命令不存在，会抛出一个 Error 对象。可以使用 try...catch 语句来捕获这个错误。

const { spawn } = require('child_process');

try {
  const child = spawn('nonexistent-command');
} catch (err) {
  console.error(`Failed to start child process: ${err.message}`);
}

子进程异常退出: 子进程可能会因为各种原因异常退出，比如代码错误、内存溢出等等。可以通过监听 exit 事件来捕获子进程的退出码，并进行相应的处理。

const { spawn } = require('child_process');

const child = spawn('node', ['child-with-error.js']);

child.on('exit', (code) => {
  if (code !== 0) {
    console.error(`Child process exited with error code ${code}`);
    // 进行错误处理，例如重启子进程
  }
});

信号处理: 子进程可能会收到各种信号，比如 SIGTERM (终止信号)、SIGINT (中断信号) 等等。可以通过监听 signal 事件来捕获这些信号，并进行相应的处理。

const { spawn } = require('child_process');

const child = spawn('node', ['long-running-script.js']);

child.on('signal', (signal) => {
  console.log(`Child process received signal ${signal}`);
  // 进行信号处理，例如优雅地关闭子进程
});

防止僵尸进程: 如果父进程没有正确处理子进程的退出，可能会导致僵尸进程。可以使用 waitpid 系统调用来避免僵尸进程。Node.js 提供了 child.unref() 方法来实现类似的功能。

六、最佳实践

使用绝对路径: 在 spawn 函数中，尽量使用命令的绝对路径，避免依赖环境变量。
参数转义: 如果命令的参数包含特殊字符，需要进行转义，以避免安全问题。
资源限制: 可以使用 options 对象的 uid、gid、cwd、env 等选项来限制子进程的资源使用。
超时控制: 可以使用 setTimeout 函数来设置子进程的超时时间，防止子进程长时间运行。
日志记录: 记录子进程的输出和错误信息，方便调试和排错。
优雅关闭: 在父进程退出时，发送信号给子进程，让子进程优雅地关闭。

总结

spawn、detached、stdio 重定向和 IPC 通信是 child_process 模块的核心功能。掌握了这些技能，你就可以轻松地创建和管理子进程，实现各种复杂的应用场景。

希望今天的讲座对你有所帮助。下次再见！

发表回复 取消回复

发表回复取消回复