一文探究Node中的進程與子進程

這篇文章帶大家深入理解下Node的進程與子進程，希望對大家有幫助！

程式：process模組

process 模組是nodejs 提供給開發者用來和目前行程互動的工具，它的提供了很多實用的API。從文件出發，管中窺豹，進一步認識並學習 process 模組：

• 如何處理指令參數？
• 如何處理工作目錄？
• 如何處理異常？
• 如何處理進程退出？
• process 的標準流物件
• 深入理解process.nextTick

【相關教學推薦：nodejs影片教學】

如何處理指令參數？

命令列參數指的是 2 個面向：

• 傳給 node 的參數。例如 node --harmony script.js --version 中，--harmony 就是傳給 node 的參數
• 傳給程序的參數。例如node script.js --version --help 中，--version --help 就是傳給進程的參數

它們分別通過process.argv 和process.execArgv 來取得。

如何處理工作目錄？

透過process.cwd()可以取得目前的工作目錄。

透過process.chdir(directory)可以切換目前的工作目錄，失敗後會拋出例外。實作如下：

function safeChdir(dir) {
    try {
        process.chdir(dir);
        return true;
    } catch (error) {
        return false;
    }
}

如何處理例外狀況？

uncaughtException 事件

Nodejs 可以透過 try-catch 來擷取例外。如果異常未捕獲，則會一直從底向事件循環冒泡。如是冒泡到事件循環的異常沒被處理，那麼就會導致目前進程異常退出。

根據文檔，可以透過監聽process 的uncaughtException 事件，來處理未捕獲的異常：

process.on("uncaughtException", (err, origin) => {
    console.log(err.message);
});

const a = 1 / b;
console.log("abc"); // 不会执行

上面的程式碼，控制台的輸出是：b is not defined。捕獲了錯誤訊息，並且進程以0退出。開發者可以在 uncaughtException 事件中，清除一些已指派的資源（檔案描述子、句柄等），不建議在其中重新啟動程序。

unhandledRejection 事件

如果一個Promise 回呼的例外沒有被.catch()捕獲，那麼就會觸發process 的unhandledRejection 事件：

process.on("unhandledRejection", (err, promise) => {
    console.log(err.message);
});

Promise.reject(new Error("错误信息")); // 未被catch捕获的异常，交由unhandledRejection事件处理

warning 事件

警告不是Node.js 和Javascript 錯誤處理流程的正式組成部分。一旦偵測到可能導致應用效能問題，缺陷或安全隱患相關的程式碼實踐，Node.js 就可發出警告。

例如前一段程式碼中，如果出現未被捕獲的 promise 回呼的異常，那麼就會觸發 warning 事件。

如何處理進程退出？

process.exit() vs process.exitCode

一個 nodejs 進程，可以透過 process.exit() 來指定退出程式碼，直接退出。 不建議直接使用 process.exit()，這會導致事件循環中的任務直接不被處理，以及可能導致資料的截斷和遺失（例如 stdout 的寫入）。

setTimeout(() => {
    console.log("我不会执行");
});

process.exit(0);

正確安全的處理是，設定 process.exitCode，並允許進程自然退出。

setTimeout(() => {
    console.log("我不会执行");
});

process.exitCode = 1;

beforeExit 事件

用於處理行程退出的事件有：beforeExit 事件 和 exit 事件。

當 Node.js 清空其事件循環且沒有其他工作要排程時，會觸發 beforeExit 事件。例如在退出前需要一些非同步操作，那麼可以寫在 beforeExit 事件中：

let hasSend = false;
process.on("beforeExit", () => {
    if (hasSend) return; // 避免死循环

    setTimeout(() => {
        console.log("mock send data to serve");
        hasSend = true;
    }, 500);
});

console.log(".......");
// 输出：
// .......
// mock send data to serve

注意：在 beforeExit 事件中如果是非同步任務，那麼又會被加入到任務佇列。此時，任務佇列完成所有任務後，又回觸發 beforeExit 事件。因此，不處理的話，可能出現死循環的情況。如果是明確呼叫 exit()，那麼不會觸發此事件。

exit 事件

在 exit 事件中，只能執行同步操作。在呼叫 'exit' 事件監聽器之後，Node.js 程序將立即退出，導致在事件循環中仍排隊的任何其他工作被放棄。

process 的標準流物件

process 提供了 3 個標準流。需要注意的是，它們有些在某些時候是同步阻塞的（請參閱文件）。

• process.stderr：WriteStream 类型，console.error的底层实现，默认对应屏幕
• process.stdout：WriteStream 类型，console.log的底层实现，默认对应屏幕
• process.stdin：ReadStream 类型，默认对应键盘输入

下面是基于“生产者-消费者模型”的读取控制台输入并且及时输出的代码：

process.stdin.setEncoding("utf8");

process.stdin.on("readable", () => {
    let chunk;
    while ((chunk = process.stdin.read()) !== null) {
        process.stdout.write(`>>> ${chunk}`);
    }
});

process.stdin.on("end", () => {
    process.stdout.write("结束");
});

关于事件的含义，还是请看stream 的文档。

深入理解 process.nextTick

我第一次看到 process.nextTick 的时候是比较懵的，看文档可以知道，它的用途是：把回调函数作为微任务，放入事件循环的任务队列中。但这么做的意义是什么呢？

因为 nodejs 并不适合计算密集型的应用，一个进程就一个线程，在当下时间点上，就一个事件在执行。那么，如果我们的事件占用了很多 cpu 时间，那么之后的事件就要等待非常久。所以，nodejs 的一个编程原则是尽量缩短每一个事件的执行事件。process.nextTick 的作用就在这，将一个大的任务分解成多个小的任务。示例代码如下：

// 被拆分成2个函数执行
function BigThing() {
    doPartThing();

    process.nextTick(() => finishThing());
}

在事件循环中，何时执行 nextTick 注册的任务呢？请看下面的代码：

setTimeout(function() {
    console.log("第一个1秒");
    process.nextTick(function() {
        console.log("第一个1秒：nextTick");
    });
}, 1000);

setTimeout(function() {
    console.log("第2个1秒");
}, 1000);

console.log("我要输出1");

process.nextTick(function() {
    console.log("nextTick");
});

console.log("我要输出2");

输出的结果如下，nextTick 是早于 setTimeout：

我要输出1
我要输出2
nextTick
第一个1秒
第一个1秒：nextTick
第2个1秒

在浏览器端，nextTick 会退化成 setTimeout(callback, 0)。但在 nodejs 中请使用 nextTick 而不是 setTimeout，前者效率更高，并且严格来说，两者创建的事件在任务队列中顺序并不一样（请看前面的代码）。

子进程：child_process模块

掌握 nodejs 的 child_process 模块能够极大提高 nodejs 的开发能力，例如主从进程来优化 CPU 计算的问题，多进程开发等等。本文从以下几个方面介绍 child_process 模块的使用：

• 创建子进程
• 父子进程通信
• 独立子进程
• 进程管道

创建子进程

nodejs 的 child_process 模块创建子进程的方法：spawn, fork, exec, execFile。它们的关系如下：

• fork, exec, execFile 都是通过 spawn 来实现的。
• exec 默认会创建 shell。execFile 默认不会创建 shell，意味着不能使用 I/O 重定向、file glob，但效率更高。
• spawn、exec、execFile 都有同步版本，可能会造成进程阻塞。

child_process.spawn()的使用：

const { spawn } = require("child_process");
// 返回ChildProcess对象，默认情况下其上的stdio不为null
const ls = spawn("ls", ["-lh"]);

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

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

ls.on("close", code => {
    console.log(`子进程退出，退出码 ${code}`);
});

child_process.exec()的使用：

const { exec } = require("child_process");
// 通过回调函数来操作stdio
exec("ls -lh", (err, stdout, stderr) => {
    if (err) {
        console.error(`执行的错误: ${err}`);
        return;
    }
    console.log(`stdout: ${stdout}`);
    console.error(`stderr: ${stderr}`);
});

父子进程通信

fork()返回的 ChildProcess 对象，监听其上的 message 事件，来接受子进程消息；调用 send 方法，来实现 IPC。

parent.js 代码如下：

const { fork } = require("child_process");
const cp = fork("./sub.js");
cp.on("message", msg => {
    console.log("父进程收到消息：", msg);
});
cp.send("我是父进程");

sub.js 代码如下：

process.on("message", m => {
    console.log("子进程收到消息：", m);
});

process.send("我是子进程");

运行后结果：

父进程收到消息： 我是子进程
子进程收到消息： 我是父进程

独立子进程

在正常情况下，父进程一定会等待子进程退出后，才退出。如果想让父进程先退出，不受到子进程的影响，那么应该：

• 调用 ChildProcess 对象上的unref()
• options.detached 设置为 true
• 子进程的 stdio 不能是连接到父进程

main.js 代码如下：

const { spawn } = require("child_process");
const subprocess = spawn(process.argv0, ["sub.js"], {
    detached: true,
    stdio: "ignore"
});

subprocess.unref();

sub.js 代码如下：

setInterval(() => {}, 1000);

进程管道

options.stdio 选项用于配置在父进程和子进程之间建立的管道。 默认情况下，子进程的 stdin、 stdout 和 stderr 会被重定向到 ChildProcess 对象上相应的 subprocess.stdin、subprocess.stdout 和 subprocess.stderr 流。 这意味着可以通过监听其上的 data事件，在父进程中获取子进程的 I/O 。

可以用来实现“重定向”：

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 定向到一个文件。
    ]
});

也可以用来实现"管道运算符"：

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

const ps = spawn("ps", ["ax"]);
const grep = spawn("grep", ["ssh"]);

ps.stdout.on("data", data => {
    grep.stdin.write(data);
});

ps.stderr.on("data", err => {
    console.error(`ps stderr: ${err}`);
});

ps.on("close", code => {
    if (code !== 0) {
        console.log(`ps 进程退出，退出码 ${code}`);
    }
    grep.stdin.end();
});

grep.stdout.on("data", data => {
    console.log(data.toString());
});

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

grep.on("close", code => {
    if (code !== 0) {
        console.log(`grep 进程退出，退出码 ${code}`);
    }
});

更多node相关知识，请访问：nodejs 教程！

以上是一文探究Node中的進程與子進程的詳細內容。更多資訊請關注PHP中文網其他相關文章！