Nodejs child_process 模块

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);
}

exec 调用 execFile

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

wiki Spawn (computing)

计算中的 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 源码

通过 spawn 创建子进程

ChildProcess.prototype.spawn

ChildProcess.prototype.spawn 创建子进程源码

通过 ChildProcess.prototype.spawn 创建子进程，通过 c++ 的 Pipe 创建不同 pipe 实例的和 Process 创建进程，这里可以看下 stido 中 pipe 和 ipc 模式创建不同的 Pipe 实例
pipe ipc 创建 Pipe 实例的区别

setupChannel 为 ipc 添加 send() 方法监听 IPC 通信数据

setupChannel 添加 ipc send() 方法

为子进程添加 IPC 通信方法

利用多进程工作推荐 through2 作者的另一个受欢迎的工具 worker-farm 也是 webpack 多进程打包的工具。

child_process 模块源码构图

child_process

参考

child_process和IPC探究
【node源码】child_process源码阅读
线程和进程