Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "how to do asynchronous computing with the multithreading capability of Node.js". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

It is said that Node.js can achieve high-performance servers, so what is high-performance?

All software code is ultimately run through CPU. Whether CPU can be used efficiently or not is a sign to distinguish between high and low performance, that is to say, it should not be idled.

When will it be idling?

When the program is doing network and disk IO, the CPU is idle, that is, idle.

Multicore CPU can run multiple programs at the same time, if only one core is used, then the other cores are idling.

Therefore, to achieve high performance, it is necessary to solve these two problems.

The operating system provides the abstraction of threads, and different execution branches of the code can run on different CPU at the same time, which is a way to take advantage of many core CPU performance.

And if some threads are doing IO, that is, waiting for reading and writing to be completed, this is a relatively inefficient way, so the operating system implements the mechanism of DMA, that is, the device controller, in which the hardware is responsible for handling from the device to memory, and let CPU know when it is finished. In this way, when some threads are in IO, they can pause the thread and wait until it is notified that the DMA shipping data is complete.

Multithreading, DMA, which is the solution provided by the operating system that takes advantage of many core CPU to solve IO problems such as CPU blocking.

This mechanism is encapsulated by various programming languages, and so is Node.js. The reason why Node.js is high performance is because of the design of asynchronous IO.

Node.js 's asynchronous IO is implemented in libuv, based on asynchronous system calls provided by the operating system, which are generally hardware-level asynchronous, such as DMA handling data. But some of the synchronous system calls will also become asynchronous after being encapsulated by libuv, because there is a thread pool in the libuv to perform these tasks, making the synchronous API asynchronous. The size of this thread pool can be set by UV_THREADPOOL_SIZE 's environment variable, which defaults to 4.

Many of the asynchronous API that we call in the code are implemented through threads.

For example:

Const fsPromises = require ('fs'). Promises;const data = await fsPromises.readFile ('. / filename')

However, this kind of asynchronous API only solves the problem of IO, so how to take advantage of multicore CPU to do calculation?

Node.js experimentally introduced the worker_thread module in 10.5 (officially introduced in 12), which allows you to create threads and eventually run with multiple CPU, which is a way to do calculations using multicore CPU.

Asynchronous API can use multithreading to do IO, while worker_thread can create threads to do calculations for different purposes.

To talk about worker_thread, you have to start with the web worker of the browser.

Web worker of the browser

Browsers also face the problem of not being able to do calculations using multicore CPU, so html5 introduces web worker, which can be calculated through another thread.

(async function () {const res = await runCalcWorker (2,3,3,3); console.log (res);}) (); function runCalcWorker (. Nums) {return new Promise ((resolve, reject) = > {const calcWorker = new Worker ('. / webWorker.js') CalcWorker.postMessage (nums) calcWorker.onmessage = function (msg) {resolve (msg.data);}; calcWorker.onerror = reject;});}

We create a Worker object, specify the js code running on another thread, then pass the message to it through the postMessage and receive the message through the onMessage. This process is also asynchronous, and we further encapsulated it into promise.

Then receive the data in webWorker.js, do the calculation, and then send back the result through postMessage.

/ / webWorker.jsonmessage = function (msg) {if (Array.isArray (msg.data)) {const res = msg.data.reduce ((total, cur) = > {return total + = cur;}, 0); postMessage (res);}}

In this way, we used another CPU core to run this calculation, which is no different from normal asynchronous code for writing code. But this async is actually not IO async, but computational async.

Node.js 's worker thread is similar to web worker, and I even suspect that the name of worker thread is influenced by web worker.

Worker thread of Node.js

If you implement the above asynchronous computing logic in Node.js, it goes like this:

Const runCalcWorker = require ('. / runCalcWorker'); (async function () {const res = await runCalcWorker (2,3,3,3); console.log (res);}) ()

Called asynchronously, because there is no difference between asynchronous computing and asynchronous IO in the way they are used.

/ / runCalcWorker.jsconst {Worker} = require ('worker_threads'); module.exports = function (... nums) {return new Promise (function (resolve, reject) {const calcWorker = new Worker ('. / nodeWorker.js'); calcWorker.postMessage (nums); calcWorker.on ('message', resolve); calcWorker.on (' error', reject);});}

Then asynchronous computing is implemented by creating a Worker object, specifying the JS running on another thread, then passing the message through the postMessage and receiving the message through the message. This is very similar to web worker.

/ / nodeWorker.jsconst {parentPort} = require ('worker_threads'); parentPort.on (' message', (data) = > {const res = data.reduce ((total, cur) = > {return total + = cur;}, 0); parentPort.postMessage (res);})

In the nodeWorker.js that performs the calculation, the message message is listened for, then the calculation is performed, and the data is sent back through the parentPost.postMessage.

Compare web worker and you will find something special. So, I think the api of Node.js 's worker thread is designed with reference to web worker.

However, worker thread also supports passing data through wokerData at creation time:

Const {Worker} = require ('worker_threads'); module.exports = function (... nums) {return new Promise (function (resolve, reject) {const calcWorker = new Worker ('. / nodeWorker.js', {workerData: nums}); calcWorker.on ('message', resolve); calcWorker.on (' error', reject);});}

Then workerData is used in the worker thread to fetch:

Const {parentPort, workerData} = require ('worker_threads'); const data = workerData;const res = data.reduce ((total, cur) = > {return total + = cur;}, 0); parentPort.postMessage (res)

Because there is a mechanism for passing messages, data such as functions that cannot be serialized cannot be transmitted for serialization and deserialization. This is also the characteristic of worker thread.

Comparison between Node.js 's worker thread and browser web woker

From the point of view of use, it can be encapsulated into ordinary asynchronous calls, which is no different from other asynchronous API.

All have to go through data serialization and deserialization, and all support postMessage and onMessage to send and receive messages.

In addition to message,Node.js 's worker thread, there are more ways to pass data, such as workerData.

But in essence, both are designed to achieve asynchronous computing, making full use of the performance of multicore CPU, there is no difference.

Summary

High-performance programs that is to make full use of CPU resources, do not let it idle, that is, do not let CPU and so on when IO, multi-core CPU should also be able to use to do computing. The operating system provides threading and DMA mechanisms to solve this problem. Node.js also has the corresponding encapsulation, that is, the api of asynchronous IO implemented by libuv, but the calculation of async was officially introduced by Node 12, that is, the worker thread,api design refers to the browser's web worker, and messages are passed through postMessage and onMessage, so the data needs to be serialized, so the function cannot be passed.

From the point of view of use, asynchronous computing and asynchronous IO are used in the same way, but asynchronous IO only makes cpu wait for IO to complete with different blocking. Asynchronous computing uses multi-core CPU to perform parallel computing at the same time, which improves computing performance several times.

This is the end of the content of "how to do asynchronous computing with the multithreading capability of Node.js". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.