Mari kita bincangkan tentang cara Node.js worker_threads melaksanakan multi-threading? (penjelasan terperinci)

Artikel ini akan memperkenalkan anda kepada modul worker_threads, memperkenalkan cara menggunakan worker_threads untuk melaksanakan multi-threading dalam Node dan menggunakan worker_threads untuk melaksanakan jujukan Fibonacci sebagai contoh yang praktikal berguna kepada semua orang!

Biasanya, Node.js dianggap sebagai satu benang. Benang utama melaksanakan kod program langkah demi langkah mengikut urutan pengekodan Setelah kod penyegerakan disekat, utas utama akan diduduki, dan pelaksanaan seterusnya kod program akan tersekat. Betul, utas tunggal Node.js merujuk kepada utas utama sebagai "benang tunggal".

Untuk menyelesaikan masalah yang disebabkan oleh satu utas, protagonis artikel ini worker_threads muncul. worker_threads mula-mula muncul dalam Node.js v10.5.0 sebagai ciri percubaan dan memerlukan --experimental-worker untuk digunakan dalam baris arahan. Ia tidak boleh digunakan secara rasmi sehingga v12.11.0 versi stabil.

Artikel ini akan memperkenalkan cara menggunakan worker_threads dan menggunakan worker_threads untuk melaksanakan jujukan Fibonacci sebagai contoh praktikal.

Prasyarat

Untuk membaca dan menggunakan artikel ini, anda perlu mempunyai:

• Dipasang Node.js v12.11.0 dan ke atas
• Kuasai asas pengaturcaraan segerak dan tak segerak JavaScript
• Kuasai cara Node.js berfungsi

Pengenalan kepada worker_threads

worker_threads Modul membenarkan penggunaan utas yang melaksanakan JavaScript secara selari.

Benang pekerja berguna untuk melaksanakan operasi JavaScript intensif CPU. Mereka tidak begitu membantu untuk kerja intensif I/O. Operasi I/O tak segerak terbina dalam Node.js adalah lebih cekap daripada benang pekerja.

berbeza daripada child_process atau cluster kerana worker_threads boleh berkongsi memori. Mereka melakukan ini dengan mengangkut ArrayBuffer tika atau berkongsi SharedArrayBuffer tika.

worker_threads telah terbukti sebagai penyelesaian terbaik untuk menggunakan sepenuhnya prestasi CPU kerana ciri-ciri berikut:

• Mereka menjalankan satu proses dengan berbilang benang.

• Setiap urutan melaksanakan gelung acara.

• Jalankan satu contoh enjin JS setiap utas.

• Setiap urutan melaksanakan satu contoh Nodej tunggal.

Cara worker_threads berfungsi

worker_threads berfungsi dengan melaksanakan 主线程 yang ditentukan oleh 脚本文件. Setiap utas dilaksanakan secara berasingan daripada utas lain. Walau bagaimanapun, urutan ini boleh menghantar mesej berulang-alik melalui saluran mesej.

主线程 menggunakan fungsi worker.postMessage() untuk menggunakan saluran mesej, manakala 工作线程 menggunakan fungsi parentPort.postMessage().

Tingkatkan pemahaman anda melalui kod contoh rasmi:

const {
  Worker, isMainThread, parentPort, workerData
} = require('worker_threads');

if (isMainThread) {
  module.exports = function parseJSAsync(script) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, {
        workerData: script
      });
      worker.on('message', resolve);
      worker.on('error', reject);
      worker.on('exit', (code) => {
        if (code !== 0)
          reject(new Error(`Worker stopped with exit code ${code}`));
      });
    });
  };
} else {
  const { parse } = require('some-js-parsing-library');
  const script = workerData;
  parentPort.postMessage(parse(script));
}

Kedua-dua kod di atas 主线程 dan 工作线程 menggunakan kod yang sama fail untuk Skrip pelaksanaan (__filename ialah laluan fail pelaksanaan semasa), gunakan isMainThread untuk membezakan 主线程 dan 工作线程 logik masa jalan. Apabila kaedah pendedahan luaran modul parseJSAsync dipanggil, urutan sub-pekerja akan dihasilkan untuk melaksanakan fungsi parse panggilan.

penggunaan khusus worker_threads

Dalam bahagian ini, kami menggunakan contoh khusus untuk memperkenalkan penggunaan worker_threads

Buat fail skrip 工作线程 workerExample.js:

const { workerData, parentPort } = require('worker_threads')
parentPort.postMessage({ welcome: workerData })

Buat 主线程fail skripmain.js:

const { Worker } = require('worker_threads')

const runWorker = (workerData) => {
    return new Promise((resolve, reject) => {
        // 引入 workerExample.js `工作线程`脚本文件
        const worker = new Worker('./workerExample.js', { workerData });
        worker.on('message', resolve);
        worker.on('error', reject);
        worker.on('exit', (code) => {
            if (code !== 0)
                reject(new Error(`stopped with  ${code} exit code`));
        })
    })
}

const main = async () => {
    const result = await runWorker('hello worker threads')
    console.log(result);
}

main().catch(err => console.error(err))

Pelaksanaan baris arahan konsol:

node main.js

Output:

{ welcome: 'hello worker threads' }

worker_threads beroperasi pada Jujukan Fibonacci

Dalam bahagian ini, mari kita lihat contoh intensif CPU untuk menjana Jujukan Fibonacci.

Jika tugasan ini diselesaikan tanpa utas pekerja, utas utama akan disekat apabila tarikh akhir nth meningkat.

Buat 工作线程fail skripworker.js

const {parentPort, workerData} = require("worker_threads");

parentPort.postMessage(getFibonacciNumber(workerData.num))

function getFibonacciNumber(num) {
    if (num === 0) {
        return 0;
    }
    else if (num === 1) {
        return 1;
    }
    else {
        return getFibonacciNumber(num - 1) + getFibonacciNumber(num - 2);
    }
}

Buat 主线程fail skripmain.js:

const {Worker} = require("worker_threads");

let number = 30;

const worker = new Worker("./worker.js", {workerData: {num: number}});

worker.once("message", result => {
    console.log(`${number}th Fibonacci Result: ${result}`);
});

worker.on("error", error => {
    console.log(error);
});

worker.on("exit", exitCode => {
    console.log(`It exited with code ${exitCode}`);
})

console.log("Execution in main thread");

Pelaksanaan baris arahan konsol:

node main.js

Output:

Execution in main thread
30th Fibonacci Result: 832040
It exited with code 0

Dalam fail main.js kita mencipta urutan pekerja daripada contoh kelas, Worker seperti yang kita lihat dalam contoh sebelumnya.

Untuk mendapatkan keputusan, kami mendengar 3 acara,

• message响应工作线程发出消息。
• exit在工作线程停止执行的情况下触发的事件。
• error发生错误时触发。

我们在最后一行main.js，

console.log("Execution in main thread");

通过控制台的输出可得，主线程并没有被斐波那契数列运算执行而阻塞。

因此，只要在工作线程中处理 CPU 密集型任务，我们就可以继续处理其他任务而不必担心阻塞主线程。

结论

Node.js 在处理 CPU 密集型任务时一直因其性能而受到批评。通过有效地解决这些缺点，工作线程的引入提高了 Node.js 的功能。

有关worker_threads的更多信息，请在此处访问其官方文档。

思考

文章结束前留下思考，后续会在评论区做补充，欢迎一起讨论。

• worker_threads线程空闲时候会被回收吗?
• worker_threads共享内存如何使用?
• 既然说到线程，那么应该有线程池?

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

Atas ialah kandungan terperinci Mari kita bincangkan tentang cara Node.js worker_threads melaksanakan multi-threading? (penjelasan terperinci). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!