Artikel untuk membincangkan proses dan sub-proses dalam Node.js

Artikel ini akan memberi anda pemahaman yang mendalam tentang proses dan sub-proses dalam Nod Saya harap ia akan membantu anda!

Proses: modul proses

Modul proses ialah alat yang disediakan oleh nodejs untuk pembangun berinteraksi dengan proses semasa banyak API praktikal. [Cadangan tutorial berkaitan: tutorial video nodejs]

Mulakan daripada dokumentasi, dapatkan pandangan sekilas tentang harimau bintang dan fahami dan pelajari modul proses selanjutnya:

• Bagaimana untuk mengendalikan parameter arahan?
• Bagaimana untuk berurusan dengan direktori kerja?
• Bagaimana untuk mengendalikan pengecualian?
• Bagaimana untuk mengendalikan proses keluar?
• Objek strim standard proses
• Pemahaman mendalam tentang proses.nextTick

Bagaimana untuk mengendalikan parameter arahan?

Parameter baris arahan merujuk kepada 2 aspek:

• Parameter dihantar ke nod. Contohnya, dalam node --harmony script.js --version, --harmony ialah parameter yang dihantar ke nod
• Parameter yang dihantar ke proses. Contohnya, dalam node script.js --version --help, --version --help ialah parameter yang dihantar kepada proses

, yang diperoleh melalui process.argv dan process.execArgv masing-masing.

Bagaimana untuk berurusan dengan direktori kerja?

Direktori kerja semasa boleh diperolehi melalui process.cwd().

Anda boleh menukar direktori kerja semasa melalui process.chdir(directory), dan pengecualian akan dilemparkan jika gagal. Amalannya adalah seperti berikut:

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

Bagaimana untuk mengendalikan pengecualian?

acara uncaughtException

Nodejs boleh menangkap pengecualian melalui try-catch. Jika pengecualian tidak ditangkap, ia akan sentiasa menggelembung dari bawah ke gelung acara. Jika pengecualian yang menggelembung sehingga gelung peristiwa tidak dikendalikan, ia akan menyebabkan proses semasa keluar secara tidak normal.

Menurut dokumentasi, anda boleh mengendalikan pengecualian yang tidak ditangkap dengan mendengar peristiwa proses uncaughtException:

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

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

Untuk kod di atas, output konsol ialah: b is not defined. Mesej ralat ditangkap dan proses keluar dengan 0. Pembangun boleh mengosongkan beberapa sumber yang diperuntukkan (deskriptor fail, pemegang, dll.) dalam acara uncaughtException, dan memulakan semula proses tidak disyorkan.

acara UnhandledRejection

Jika pengecualian panggil balik Promise tidak ditangkap oleh .catch(), maka peristiwa unhandledRejection proses akan dicetuskan:

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

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

acara amaran

Amaran bukan bahagian formal dalam proses pengendalian ralat Node.js dan Javascript. Node.js boleh mengeluarkan makluman sebaik sahaja ia mengesan amalan pengekodan yang boleh membawa kepada isu prestasi aplikasi, kecacatan atau risiko keselamatan.

Sebagai contoh, dalam kod sebelumnya, jika pengecualian panggilan balik janji yang tidak ditangkap berlaku, peristiwa amaran akan dicetuskan. Rujuk penjelasan video lanjutan nodejs: Masukkan pembelajaran

Bagaimana untuk mengendalikan proses keluar?

process.exit() vs process.exitCode

Proses nodejs, anda boleh menentukan kod keluar melalui process.exit(), terus berhenti. Adalah tidak disyorkan untuk menggunakan process.exit() secara langsung, yang akan menyebabkan tugasan dalam gelung peristiwa tidak diproses secara langsung dan boleh menyebabkan pemangkasan dan kehilangan data (seperti menulis kepada stdout).

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

process.exit(0);

Pengendalian yang betul dan selamat ialah menetapkan process.exitCode dan membenarkan proses keluar secara semula jadi.

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

process.exitCode = 1;

beforeExit event

Acara yang digunakan untuk mengendalikan proses exit ialah: beforeExit event dan exit event.

Acara beforeExit dicetuskan apabila Node.js mengosongkan gelung acaranya dan tidak mempunyai kerja lagi untuk dijadualkan. Contohnya, jika anda memerlukan beberapa operasi tak segerak sebelum keluar, anda boleh menulisnya dalam acara 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

Nota: Jika ia adalah tugas tak segerak dalam acara beforeExit, ia akan ditambahkan pada tugasan beratur. Pada masa ini, selepas baris gilir tugasan menyelesaikan semua tugasan, acara beforeExit dicetuskan semula. Oleh itu, jika tidak dikendalikan, gelung tak terhingga mungkin berlaku . Jika exit() dipanggil secara eksplisit, acara ini tidak akan dicetuskan.

keluar acara

Dalam acara keluar, hanya operasi segerak boleh dilakukan. Selepas memanggil pendengar acara 'keluar', proses Node.js akan keluar serta-merta, menyebabkan sebarang kerja lain yang masih beratur dalam gelung acara akan ditinggalkan.

Objek aliran standard proses

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 教程！

Atas ialah kandungan terperinci Artikel untuk membincangkan proses dan sub-proses dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!