Let's talk about how Node.js + worker_threads implements multi-threading? (detailed explanation)

This article will take you to understand the worker_threads module, introduce how to use worker_threads to implement multi-threading in Node, and use worker_threads to execute the Fibonacci sequence as a practical example. I hope it will be helpful to everyone. !

Normally, Node.js is considered single-threaded. The main thread executes the program code step by step according to the coding sequence. Once the synchronization code is blocked, the main thread will be occupied, and subsequent execution of the program code will be stuck. That's right, the single thread of Node.js refers to the main thread being "single threaded".

In order to solve the problems caused by single thread, the protagonist of this article worker_threads appears. worker_threads first appeared as an experimental feature in Node.js v10.5.0. You need to bring --experimental-worker on the command line to use it. It will not be officially used until the v12.11.0 stable version.

This article will introduce how to use worker_threads, and use worker_threads to execute Fibonacci sequence as a practical example.

Prerequisites

To read and consume this article, you need to have:

• InstalledNode.js v12.11.0 and above version
• Master the basic knowledge of JavaScript synchronous and asynchronous programming
• Master the working principle of Node.js

worker_threads introduction

worker_threads The module allows the use of threads that execute JavaScript in parallel.

Worker threads are useful for performing CPU-intensive JavaScript operations. They are not very helpful for I/O intensive work. Node.js's built-in asynchronous I/O operations are more efficient than worker threads.

Unlike child_process or cluster, worker_threads can share memory. They do this by transferring ArrayBuffer instances or sharing SharedArrayBuffer instances.

worker_threads have proven to be the best solution to fully utilize the CPU performance due to the following characteristics:

• They run with multiple threads single process.

• Each thread executes an event loop.

• Run a single instance of the JS engine per thread.

• Each thread executes a single Nodejs instance.

How worker_threads works

worker_threadsBy executing the main threadspecified script File to work. Each thread executes in isolation from other threads. However, these threads can pass messages back and forth through message channels.

Main threadUse worker.postMessage() function uses the message channel, while Worker threaduses parentPort.postMessage()function.

Enhance your understanding through the official sample code:

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));
}

The above codeMain thread and Worker threadUse the same file as the execution script (__filename is the current execution file path), and use isMainThread to distinguish main thread and worker threadRuntime logic. When the module's externally exposed method parseJSAsync is called, a sub-worker thread will be spawned to execute the parse function.

Worker_threads specific use

In this section, we use specific examples to introduce the use of worker_threads

Create worker threadScript fileworkerExample.js:

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

CreateMain threadScript filemain.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))

Control Taiwan command line execution:

node main.js

Output:

{ welcome: 'hello worker threads' }

worker_threads Operation Fibonacci Sequence

In this section, let’s take a look at the CPU Intensive example, generating Fibonacci Sequence.

If this task is completed without a worker thread, the main thread will be blocked as the nth deadline increases.

CreateWorker threadScript fileworker.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);
    }
}

CreateMain threadScript filemain.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");

Console command line execution:

node main.js

Output:

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

In the main.js file, we start from the class Instance creates a worker thread, Worker as we saw in the previous example.

In order to get the results, we listen to 3 events,

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

The above is the detailed content of Let's talk about how Node.js + worker_threads implements multi-threading? (detailed explanation). For more information, please follow other related articles on the PHP Chinese website!