详解node多进程child_process用法及原理

child_process用法

child_process的api:
  • 异步api:
    1. exec(cmd, options, callback)
    2. execFile(cmd, args, options, callback)
    3. fork (模块路径, args, options) // 不一样的地方在于可以通信
    4. spawn(cmd, args, options)
    • exec用法:
      执行shell脚本, 使用管道符也是可以的
      exec也是可以执行文件的,只不过不能传参数
      适合我开销比较小的任务
    const cp = require('child_process')
    cp.exec('ls -al|grep node_modules', { 
      timeout: 0, // 超时时间
      cwd: process.cwd(), // 可以改变当前的执行路径
      }, function (err, stdout, stderr) {
      // 执行结果
    })
    
    • execFile用法:
      可以执行文件,也可以执行语句,可传参
      适合我开销比较小的任务
      // 执行文件,参数
    cp.execFile('ls', ['-al'], function (err, stdout, std,err) => {
      // 执行结果
    })
    // 让execFile执行ls -al|grep node_modules这种语句
    test.shell:
      ls -al|grep node_modules
      echo $1 // 打印参数
      echo $2
    index.js:
    cp.execFile(path.resolve(__dirname, 'test.shell'), ['-al', 'bl'], 
    function(err,   stdout, stderr) {
    })
    
    • fork用法
      用node执行, 耗时操作且用node实现,如下载文件
    // cp.fork(模块路径)
    // 和require一样把文件执行起来
    const child = cp.fork(path.resolve(__dirname, 'child_process'))
    console.log(process.pid)
    // 主进程向子进程通信
    child.send('hello child_process', () => {
      // child.disconnent() // 如果不断开,两边会出现等待的情况
    })
    // 子进程向主进程通信
    child.on('message', msg => {
      
    })
    // child_process.js:
      console.log('aaa', process.pid)
      process.on('message', msg => {
      console.log(msg)
      // 很容易出现死循环
      })
      process.send('send msg to parent')
    // 进程不一样,完全独立,本质也是调用spawn
    
    • spawn 用法
      spawn: 流式的,没有回调,适合耗时任务(比如:npm install), 需要不断打印日志(不断给用户输出日志)
cp.spawn(file, args, options) // 不支持回调, exec,execFile底层都是spwan
const child = cp.spawn(path.resolve(__dirname, 'test.shell'), ['-al', '-bl'], {
  cwd: path.resolve('..'),
}) // 返回的是子进程
console.log(child.pid, process.pid)
// 监听成功
child.stdout.on('data', function(chunk) {
  console.log(chunk.toString())
})
// 监听失败
child.stderr.on('data', function(chunk) {
  console.log(chunk.toString())
})

const code = `require('${rootFile}').call(null, ${JSON.stringify(args)})`
 // cp.spawn('cmd', ['/c', 'node', '-e', code]) // win下是这种结构
 const child = spawn('node', ['-e', code], {
   cwd: process.cwd(), // 当前执行未知的cwd
   stdio: 'inherit', // 默认是pipe,pipe必须通过on来接收信息,inherit不需要,实时反馈
 })
 child.on('error', e => {
   log.error(e.message)
   process.exit(1)
 })
child.on('exit', e => {
  log.verbose('命令执行成功', e)
  process.exit(e)
})
  • 同步api:
    • execSync
    • execFileSync
    • spawnSync
const ret = cp.execSync('ls -al|grep node_modules') // 用的比较多,对脚本安全性没有校验
// 可以直接拿到结果
console.log(ret.toString())
const ret2 = cp.execFileSync('ls', ['-al'])
console.log(ret2.toString)
const ret3 = cp.spawnSync('ls', ['-al'])
console.log(ret3.stdout.toString()) // 返回的是一个对象

child_process原理

1. exec 和 execFile有什么区别?
  • 二者只有传参不同
  • 底层调用的还是spawn
// exec源码,处理一下参数,调用的execFile
function exec(command, options, callback) {
  const opts = normalizeExecArgs(command, options, callback);
  return module.exports.execFile(opts.file,
                                 opts.options,
                                 opts.callback);
}
function execFile(file /* , args, options, callback */) {
  // ...
  // 底层调用的还是spawn
    const child = spawn(file, args, {
      cwd: options.cwd,
      env: options.env,
      gid: options.gid,
      shell: options.shell,
      signal: options.signal,
      uid: options.uid,
      windowsHide: !!options.windowsHide,
      windowsVerbatimArguments: !!options.windowsVerbatimArguments
    });
}
  1. exec: 原理是调用/bin/sh -c 执行我们传入的shell脚本,底层调用略execFile
  2. execFile:原理是直接执行我们传入的file和args,底层调用spawn创建和执行子进程,并建立略回调,一次性将所有的stdout和stderr结果返回
  3. spawn:原理是调用略internal/child_process,实例化略ChildProcess子进程对象,再调用child.spawn创建 子进程并执行命令,底层是调用了child.)handle.spawn执行process_wrap中的spwan方法,执行过程是异步的,执行完毕后再通过PIPE进行单向数据通信,通信结束后子进程发起onexit回调,同时Socket会执行close回调。
  4. fork:原理是通过spawn创建子进程和执行命令,采用node执行命令,通过setupchannel创建IPC用于子进程和父进程之间的双向通信。
2. data/error/exit/close回调的区别

data:用于主进程读取数据过程中通过onStreamRead发起的回调
error: 命令执行失败后发起的回调
exit: 子进程关闭完成后发起的回调
close:子进程所有Socket通信端口全部关闭后发起的回调
stdout close/stderr close:特定的PIPE读取完成后调用onReadableStreamEnd关闭Socket时发起的回调。

推荐阅读更多精彩内容