child_process 用户调用层
exec
child_process.exec(command[, options][, callback])
开启一个子进程执行 shell 命令，在回调中获取输出信息
child = cp.exec('ls -al', function(err, stdout, stderr) {
console.log(err);
console.log(stdout);
console.log(stderr);
});
在 lib/child_process 源码中 exec 内部只是处理参数后调用了 execFile 方法。
function exec(command, options, callback) {
const opts = normalizeExecArgs(command, options, callback);
return module.exports.execFile(opts.file, opts.options,opts.callback);
}
execFile
child_process.execFile(file[, args][, options][, callback])
// ls.shell
ls
// index.js
cp.execFile(path.resolve(__dirname, 'ls.shell'), ['-al'], function(err, stdout, stderr) {
console.log(err);
console.log(stdout);
console.log(stderr);
});
执行 execFile 流程
execFile 源码
调用 spawn 创建进程 child
通过 child.stdout.on('data') 收集输出 stdout
当 child 进程 close 时把 _stdout 传入 callback 内输出
同样当 child 进程 触发 error 事件会把 _stderr 传入 callback 中输出，同时会 destroy 进程 child 的 stdout 和 stderr
简化的 execFile
// 简化的 execFile
function execFile(file) {
options = {
encoding: 'utf8',
timeout: 0,
maxBuffer: MAX_BUFFER,
killSignal: 'SIGTERM',
cwd: null,
env: null,
shell: false,
...options // exec() 调用时 shell: true
};
const child = spawn(file, args, options)
const callback = arguments[arguments.length - 1]
const _stdout = []
const _stderr = []
const encoding = options.encoding
function exithandler(code, signal) {
if (!callback) return
let stdout, stderr
if (encoding) {
stdout = _stdout.join('')
stderr = _stderr.join('')
} else {
stdout = Buffer.concat(_stdout)
stderr = Buffer.concat(_stderr);
}
if (code === 0) {
callback(null, stdout, stderr)
return
}
callback(code, stdout, stderr)
}
function errorhandler(e) {
child.stdout.destroy();
child.stderr.destroy();
exithandler()
}
child.stdout.on('data', function onChildStdout(chunk) {
_stdout.push(chunk);
})
child._stderr.on('data', function onChildStdout(chunk) {
_stderr.push(chunk);
})
child.addListener('close', exithandler);
child.addListener('error', errorhandler);
return child
}
exec execFile 总结
execFile 通过 spawn 创建子进程执行命令，是 nodejs 围绕 spawn 方法的封装， 调用 spawn 执行命令一次性的把输出结果和错误通过回调输出。
exec 底层调用了 execFile，不过 exec 通过 option.shell = true 的配置使 spawn 创建的进程通过 /bin/sh -c 执行传入的 shell 脚本
适合执行开销小的命令
spawn
计算中的 Spawn 是指加载并执行新子进程的函数。当前进程可以等待子进程终止，也可以继续执行并发计算。创建一个新的子进程需要足够的内存，子进程和当前程序都可以在其中执行。
spawn 执行命令
child_process.spawn(command[, args][, options])
// 默认执行
const child = spawn('ls', ['-lh'], {})
let out = ''
child.stdout.on('data', function(chunk) {
out += chunk // 通过 data 事件获得输出
})
child.stdout.on('close', function() {
console.log(out); // 执行完毕 emit close 事件
});
- spawn 与 exec 执行命令的区别
没有回调函数，因为 exec 是封装了 spawn 创建 child_process 的 事件 api ，最后一次性的输出结果 相比 spawn 创建子进程异步执行时把输入输出默认通过 pipe 进行传输，利用 pipe 更适合执行开销较大的命令。
封装可用的 spawn 执行命令工具方法
function runCmd(cmd, _args, fn) {
const args = _args || [];
const runner = require('child_process').spawn(cmd, args, {
stdio: 'inherit',
env: process.env,
});
runner.on('close', code => {
if (fn) {
fn(code);
}
});
}
function runCmdPromisify(cmd, _args) {
const args = _args || [];
return new Promise(resolve => {
const runner = require('child_process').spawn(cmd, args, {
stdio: 'inherit',
env: process.env,
});
runner.on('close', code => {
resolve(code)
});
})
}
spawn 输入输出 options.stdio
使用 spawn 创建子进程执行 命令时 options.stdio 比较常用的配置项就是默认的 pipe 和 inherit, ignore 选项将会忽略子进程的输入输出
如果使用 inherit 选项，命令的执行内容将会直接在控制台输出，因为指定了输出的 fd 的 1 process.stdio标准输出流直接会在控制台中输出。
const child = spawn('ls', ['-lh'], {
stdio: 'inherit' // [0, 1, 2]
})
如果使用 pipe 选项，child.stdout 也可以通过 pipe 输出流的方式输出到可写流中， 比如 fs.createWriteStream 简单的文件可写流。
const ws = fs.createWriteStream(path.resolve(__dirname, './out.txt'))
const child = spawn('ls', ['-lh'], {
stdio: 'pipe' // 默认 ['pipe', 'pipe', 'pipe']
})
child.stdout.pipe(ws)
// stdout.pipe 是 Stream 内部对 pipe 事件传输的封装方法，定义了 on('data') 等事件的回调
spawn 守护进程 options.detached
子进程在后台运行，无法访问控制台或键盘输入，将不受终端影响。
wiki spawn mode
- 开启
P_DETACH模式
// index.js
const spawn = require('child_process').spawn;
const cwd = process.cwd();
function startDaemon() {
const daemon = spawn('node', ['daemon.js'], {
cwd,
detached : true,
stdio: 'ignore',
})
console.log('父进程 pid: %s, 守护进程 pid: %s', process.pid, daemon.pid);
daemon.unref(); // 子进程解除父进程引用
}
startDaemon()
// daemon.js
const fs = require('fs');
const { Console } = require('console');
const logger = new Console(fs.createWriteStream('./stdout.log'));
setInterval(function() {
logger.log('daemon pid: ', process.pid, ', ppid: ', process.ppid);
}, 1000 * 1);
// consle
守护进程开启 父进程 pid: 13363, 守护进程 pid: 13370
// stdout.log
daemon pid: 13557 , ppid: 1
daemon pid: 13557 , ppid: 1
daemon pid: 13557 , ppid: 1
daemon pid: 13557 , ppid: 1
通过执行 index.js 执行 spwan API 设置 detached: true 创建守护进程并解除父进程引用。守护进程将会一直向 stdout.log 中写入数据。
孤儿进程
通过守护进程的例子会发现 stdout.log 写入的 父进程 ppid 与 index.js 打印出的父进程 pid 不一样。这里的 ppid：1 是 init 进程，当父进程退出后通过父进程创建还在执行的子进程将会被 init 进程收养成为孤儿进程
- 如果 daemon 进程不解除父进程引用，那么父进程将不会退出，stdout.log 输出的 ppid 会是父进程 pid
// index.js
const spawn = require('child_process').spawn;
const cwd = process.cwd();
function startDaemon() {
const daemon = spawn('node', ['daemon.js'], {
cwd,
detached : true,
stdio: 'ignore',
})
console.log('父进程 pid: %s, 守护进程 pid: %s', process.pid, daemon.pid);
// daemon.unref();
}
startDaemon()
// console
父进程 pid: 13626, 守护进程 pid: 13633
// stdout.log
daemon pid: 13633 , ppid: 13626
daemon pid: 13633 , ppid: 13626
daemon pid: 13633 , ppid: 13626
- 命令
ps -aux | grep node查看 node 进程
kill -9 ${pid}结束进程
fork
在计算机领域中，尤其是Unix及类Unix系统操作系统中，fork（进程复制）是一种创建自身行程副本的操作。它通常是内核实现的一种系统调用。Fork是类Unix操作系统上创建进程的一种主要方法，甚至历史上是唯一方法。
wiki fork (system call)
fork 创建子进程
child_process.fork(modulePath[, args][, options])
// main.js
const path = require('path')
const childProcess = require('child_process')
console.log('=== in main ===');
const child = childProcess.fork(path.resolve(__dirname, './child.js'))
child.send('a message form main') // 向子进程发送消息
console.log('main pid: ', process.pid); // 主进程 pid
// child.js
console.log('=== in child ===');
console.log('child pid: ', process.pid); // 子进程 pid
console.log('child ppid: ', process.ppid); // 父进程 pid
process.on('message', (msg) => { // 等待接收消息
console.log('child on message: ', msg);
})
// console
=== in main ===
main pid: 17635
=== in child ===
child pid: 17642
child ppid: 17635
child on message: a message form main
fork 源码
ChildProcess.prototype.spawn
ChildProcess.prototype.spawn 创建子进程源码
通过 ChildProcess.prototype.spawn 创建子进程，通过 c++ 的 Pipe 创建不同 pipe 实例的和 Process 创建进程，这里可以看下 stido 中 pipe 和 ipc 模式创建不同的 Pipe 实例
pipe ipc 创建 Pipe 实例的区别
setupChannel 为 ipc 添加 send() 方法监听 IPC 通信数据
利用多进程工作推荐 through2 作者的另一个受欢迎的工具 worker-farm 也是 webpack 多进程打包的工具。
child_process 模块源码构图
