Lassen Sie uns darüber sprechen, wie Node.js + worker_threads Multithreading implementiert. (ausführliche Erklärung)-js-Tutorial-php.cn

Dieser Artikel führt Sie durch das worker_threads-Modul, stellt vor, wie Sie worker_threads zum Implementieren von Multithreading in Node verwenden, und zeigt als praktisches Beispiel, wie Sie worker_threads zum Ausführen der Fibonacci-Sequenz verwenden!

Lassen Sie uns darüber sprechen, wie Node.js + worker_threads Multithreading implementiert. (ausführliche Erklärung)

Normalerweise gilt Node.jsNode.js被认为是单线程。由主线程去按照编码顺序一步步执行程序代码，一旦遇到同步代码阻塞，主线程就会被占用，后续的程序代码的执行都会被卡住。没错Node.js的单线程指的是主线程是"单线程"。

为了解决单线程带来的问题，本文的主角worker_threads出现了。worker_threads首次在Node.js v10.5.0作为实验性功能出现，需要命令行带上--experimental-worker才能使用。直到v12.11.0稳定版才能正式使用。

本文将会介绍worker_threads的使用方式，以及利用worker_threads执行斐波那契数列作为实践例子。

先决条件

阅读并食用本文，需要先具备：

安装了 Node.js v12.11.0 及以上版本
掌握 JavaScript 同步和异步编程的基础知识
掌握 Node.js 的工作原理

worker_threads 介绍

worker_threads 模块允许使用并行执行 JavaScript 的线程。

工作线程对于执行 CPU 密集型的 JavaScript 操作很有用。它们对 I/O 密集型的工作帮助不大。 Node.js 内置的异步 I/O 操作比工作线程更高效。

与 child_process 或 cluster 不同，worker_threads 可以共享内存。它们通过传输 ArrayBuffer 实例或共享 SharedArrayBuffer 实例来实现。

由于以下特性，worker_threads已被证明是充分利用CPU性能的最佳解决方案：

它们运行具有多个线程的单个进程。
每个线程执行一个事件循环。
每个线程运行单个 JS 引擎实例。
每个线程执行单个 Nodejs 实例。

worker_threads 如何工作

worker_threads通过执行主线程指定的脚本文件来工作。每个线程都在与其他线程隔离的情况下执行。但是，这些线程可以通过消息通道来回传递消息。

主线程使用worker.postMessage()函数使用消息通道，而工作线程使用parentPort.postMessage()函数。

通过官方示例代码加强了解：

const {
  Worker, isMainThread, parentPort, workerData
} = require(&#39;worker_threads&#39;);

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

Nach dem Login kopieren

上述代码主线程与工作线程都使用同一份文件作为执行脚本(__filename为当前执行文件路径)，通过isMainThread来区分主线程与工作线程运行时逻辑。当模块对外暴露方法parseJSAsync被调用时候，都将会衍生子工作线程去执行调用parse函数。

worker_threads 具体使用

在本节使用具体例子介绍worker_threads的使用

创建工作线程脚本文件workerExample.js:

const { workerData, parentPort } = require(&#39;worker_threads&#39;)
parentPort.postMessage({ welcome: workerData })

Nach dem Login kopieren

创建主线程脚本文件main.js:

const { Worker } = require(&#39;worker_threads&#39;)

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

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

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

Nach dem Login kopieren

控制台命令行执行:

node main.js

Nach dem Login kopieren

输出:

{ welcome: &#39;hello worker threads&#39; }

Nach dem Login kopieren

worker_threads 运算斐波那契数列

在本节中，让我们看一下 CPU 密集型示例，生成斐波那契数列。

如果在没有工作线程的情况下完成此任务，则会随着nth期限的增加而阻塞主线程。

创建工作线程脚本文件worker.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);
    }
}

Nach dem Login kopieren

创建主线程脚本文件main.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");

Nach dem Login kopieren

控制台命令行执行:

node main.js

Nach dem Login kopieren

输出:

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

Nach dem Login kopieren

在main.js文件中，我们从类的实例创建一个工作线程，Worker als Single-Threaded. Der Hauptthread führt den Programmcode Schritt für Schritt gemäß der Codierungssequenz aus. Sobald der Synchronisationscode blockiert ist, ist der Hauptthread belegt und die nachfolgende Ausführung des Programmcodes bleibt hängen. Das ist richtig, der einzelne Thread von Node.js bedeutet, dass der Hauptthread „Single-Threaded“ ist.

Um die durch einzelne Threads verursachten Probleme zu lösen, erscheint der Protagonist dieses Artikels worker_threads. worker_threads erschien erstmals als experimentelle Funktion in Node.js v10.5.0 und erfordert zur Verwendung --experimental-worker in der Befehlszeile. Es kann erst mit der stabilen Version v12.11.0 offiziell verwendet werden.

🎜In diesem Artikel erfahren Sie, wie Sie worker_threads verwenden und wie Sie worker_threads verwenden, um Fibonacci-Folge 🎜 als praktisches Beispiel. 🎜

Voraussetzungen

🎜Um diesen Artikel lesen und nutzen zu können, müssen Sie Folgendes haben: 🎜

Installierter Node.js v12.11.0 und höher
Beherrschen Sie die Grundkenntnisse der synchronen und asynchronen JavaScript-Programmierung
Beherrschen Sie das Funktionsprinzip von Node.js