在nodejs中建立child process

簡介

nodejs的main event loop是單線程的，nodejs本身也維護着Worker Pool用來處理一些耗時的操作，我們還可以通過使用nodejs提供的worker_threads來手動建立新的線程來執行自己的任務。

本文将會介紹一種新的執行nodejs任務的方式，child process。

child process

lib/child_process.js提供了child_process子產品，通過child_process我們可以建立子程序。

注意，worker_threads建立的是子線程，而child_process建立的是子程序。

在child_process子產品中，可以同步建立程序也可以異步建立程序。同步建立方式隻是在異步建立的方法後面加上Sync。

建立出來的程序用ChildProcess類來表示。

我們看下ChildProcess的定義：

interface ChildProcess extends events.EventEmitter {
        stdin: Writable | null;
        stdout: Readable | null;
        stderr: Readable | null;
        readonly channel?: Pipe | null;
        readonly stdio: [
            Writable | null, // stdin
            Readable | null, // stdout
            Readable | null, // stderr
            Readable | Writable | null | undefined, // extra
            Readable | Writable | null | undefined // extra
        ];
        readonly killed: boolean;
        readonly pid: number;
        readonly connected: boolean;
        readonly exitCode: number | null;
        readonly signalCode: NodeJS.Signals | null;
        readonly spawnargs: string[];
        readonly spawnfile: string;
        kill(signal?: NodeJS.Signals | number): boolean;
        send(message: Serializable, callback?: (error: Error | null) => void): boolean;
        send(message: Serializable, sendHandle?: SendHandle, callback?: (error: Error | null) => void): boolean;
        send(message: Serializable, sendHandle?: SendHandle, options?: MessageOptions, callback?: (error: Error | null) => void): boolean;
        disconnect(): void;
        unref(): void;
        ref(): void;

        /**
         * events.EventEmitter
         * 1. close
         * 2. disconnect
         * 3. error
         * 4. exit
         * 5. message
         */
        ...
    }

可以看到ChildProcess也是一個EventEmitter，是以它可以發送和接受event。

ChildProcess可以接收到event有5種，分别是close，disconnect，error，exit和message。

當調用父程序中的 subprocess.disconnect() 或子程序中的 process.disconnect() 後會觸發 disconnect 事件。

當出現無法建立程序，無法kill程序和向子程序發送消息失敗的時候都會觸發error事件。

當子程序結束後時會觸發exit事件。

當子程序的 stdio 流被關閉時會觸發 close 事件。注意，close事件和exit事件是不同的，因為多個程序可能共享同一個stdio，是以發送exit事件并不一定會觸發close事件。

看一個close和exit的例子：

const { spawn } = require('child_process');
const ls = spawn('ls', ['-lh', '/usr']);

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

ls.on('close', (code) => {
  console.log(`子程序使用代碼 ${code} 關閉所有 stdio`);
});

ls.on('exit', (code) => {
  console.log(`子程序使用代碼 ${code} 退出`);
});
~~~

最後是message事件，當子程序使用process.send() 發送消息的時候就會被觸發。

ChildProcess中有幾個标準流屬性，分别是stderr，stdout，stdin和stdio。

stderr，stdout，stdin很好了解，分别是标準錯誤，标準輸出和标準輸入。

我們看一個stdout的使用：

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

const subprocess = spawn('ls');

subprocess.stdout.on('data', (data) => {
  console.log(`接收到資料塊 ${data}`);
});

stdio實際上是stderr,stdout,stdin的集合：

readonly stdio: [
            Writable | null, // stdin
            Readable | null, // stdout
            Readable | null, // stderr
            Readable | Writable | null | undefined, // extra
            Readable | Writable | null | undefined // extra
        ];

其中stdio[0]表示的是stdin，stdio[1]表示的是stdout，stdio[2]表示的是stderr。

如果在通過stdio建立子程序的時候，這三個标準流被設定為除pipe之外的其他值，那麼stdin，stdout和stderr将為null。

我們看一個使用stdio的例子：

const assert = require('assert');
const fs = require('fs');
const child_process = require('child_process');

const subprocess = child_process.spawn('ls', {
  stdio: [
    0, // 使用父程序的 stdin 用于子程序。
    'pipe', // 把子程序的 stdout 通過管道傳到父程序 。
    fs.openSync('err.out', 'w') // 把子程序的 stderr 定向到一個檔案。
  ]
});

assert.strictEqual(subprocess.stdio[0], null);
assert.strictEqual(subprocess.stdio[0], subprocess.stdin);

assert(subprocess.stdout);
assert.strictEqual(subprocess.stdio[1], subprocess.stdout);

assert.strictEqual(subprocess.stdio[2], null);
assert.strictEqual(subprocess.stdio[2], subprocess.stderr);

通常情況下父程序中維護了一個對子程序的引用計數，隻有在當子程序退出之後父程序才會退出。

這個引用就是ref，如果調用了unref方法，則允許父程序獨立于子程序退出。

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

const subprocess = spawn(process.argv[0], ['child_program.js'], {
  detached: true,
  stdio: 'ignore'
});

subprocess.unref();

最後，我們看一下如何通過ChildProcess來發送消息：

subprocess.send(message[, sendHandle[, options]][, callback])

其中message就是要發送的消息，callback是發送消息之後的回調。

sendHandle比較特殊，它可以是一個TCP伺服器或socket對象，通過将這些handle傳遞給子程序。子程序将會在message事件中，将該handle傳遞給Callback函數，進而可以在子程序中進行處理。

我們看一個傳遞TCP server的例子，首先看主程序：

const subprocess = require('child_process').fork('subprocess.js');

// 打開 server 對象，并發送該句柄。
const server = require('net').createServer();
server.on('connection', (socket) => {
  socket.end('由父程序處理');
});
server.listen(1337, () => {
  subprocess.send('server', server);
});

再看子程序：

process.on('message', (m, server) => {
  if (m === 'server') {
    server.on('connection', (socket) => {
      socket.end('由子程序處理');
    });
  }
});

可以看到子程序接收到了server handle，并且在子程序中監聽connection事件。

下面我們看一個傳遞socket對象的例子：

onst { fork } = require('child_process');
const normal = fork('subprocess.js', ['normal']);
const special = fork('subprocess.js', ['special']);

// 開啟 server，并發送 socket 給子程序。
// 使用 `pauseOnConnect` 防止 socket 在被發送到子程序之前被讀取。
const server = require('net').createServer({ pauseOnConnect: true });
server.on('connection', (socket) => {

  // 特殊優先級。
  if (socket.remoteAddress === '74.125.127.100') {
    special.send('socket', socket);
    return;
  }
  // 普通優先級。
  normal.send('socket', socket);
});
server.listen(1337);

subprocess.js的内容：

process.on('message', (m, socket) => {
  if (m === 'socket') {
    if (socket) {
      // 檢查用戶端 socket 是否存在。
      // socket 在被發送與被子程序接收這段時間内可被關閉。
      socket.end(`請求使用 ${process.argv[2]} 優先級處理`);
    }
  }
});
~~~

主程序建立了兩個subprocess，一個處理特殊的優先級， 一個處理普通的優先級。

# 異步建立程序

child_process子產品有4種方式可以異步建立程序，分别是child_process.spawn()、child_process.fork()、child_process.exec() 和 child_process.execFile()。

先看一個各個方法的定義：

~~~js
child_process.spawn(command[, args][, options])

child_process.fork(modulePath[, args][, options])

child_process.exec(command[, options][, callback])

child_process.execFile(file[, args][, options][, callback])
~~~

其中child_process.spawn是基礎，他會異步的生成一個新的程序，其他的fork，exec和execFile都是基于spawn來生成的。

fork會生成新的Node.js 程序。

exec和execFile是以新的程序執行新的指令，并且帶有callback。他們的差別就在于在windows的環境中，如果要執行.bat或者.cmd檔案，沒有shell終端是執行不了的。這個時候就隻能以exec來啟動。execFile是無法執行的。

或者也可以使用spawn。

我們看一個在windows中使用spawn和exec的例子：

~~~js
// 僅在 Windows 上。
const { spawn } = require('child_process');
const bat = spawn('cmd.exe', ['/c', 'my.bat']);

bat.stdout.on('data', (data) => {
  console.log(data.toString());
});

bat.stderr.on('data', (data) => {
  console.error(data.toString());
});

bat.on('exit', (code) => {
  console.log(`子程序退出，退出碼 ${code}`);
});

const { exec, spawn } = require('child_process');
exec('my.bat', (err, stdout, stderr) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(stdout);
});

// 檔案名中包含空格的腳本：
const bat = spawn('"my script.cmd"', ['a', 'b'], { shell: true });
// 或：
exec('"my script.cmd" a b', (err, stdout, stderr) => {
  // ...
});

同步建立程序

同步建立程序可以使用child_process.spawnSync()、child_process.execSync() 和 child_process.execFileSync() ，同步的方法會阻塞 Node.js 事件循環、暫停任何其他代碼的執行，直到子程序退出。

通常對于一些腳本任務來說，使用同步建立程序會比較常用。

本文作者：flydean程式那些事

本文連結：
http://www.flydean.com/nodejs-childprocess/
本文來源：flydean的部落格

歡迎關注我的公衆号:「程式那些事」最通俗的解讀，最深刻的幹貨，最簡潔的教程，衆多你不知道的小技巧等你來發現！

在nodejs中建立child process簡介child process同步建立程序

簡介

child process

同步建立程序

繼續閱讀

JavaScript的那些坑之事件代理事件代理事件階段

Shell程式設計——sort排序、uniq忽略重複、tr替換壓縮删除、cut指定删除字段、正規表達式元字元sort 指令uniq 指令tr 指令cut 指令正規表達式

javascript的for (var i in data)慎用javascript中的for (var i in data)謹慎用

Linxu常用指令技巧彙總

Windows下配置Apache的SSL服務

《Linux指令行與Shell腳本程式設計大全第2版.布盧姆》pdf

Mac｜Windows系統本地照片自動上傳到伺服器

tab滑鼠經過菜單切換

ACS基本配置-權限等級管理

vue （vue2.0）使用總結(從大體結構總結)

vue搭建過程及出現問題

/\B(?=(?:\d{3})+$)/g 一條令人費解的正規表達式

适用于JavaScript的ECMAScript 2020規範向前發展

JS生成uuid的四種方法

layui多任務上傳添加進度條