我是靠谱客的博主 可耐老鼠,最近开发中收集的这篇文章主要介绍聊聊Node.js + worker_threads如何实现多线程?(详解),觉得挺不错的,现在分享给大家,希望可以做个参考。

概述

本篇文章带大家了解一下worker_threads 模块,介绍一下在Node中如何使用worker_threads实现多线程,以及利用worker_threads执行斐波那契数列作为实践例子,希望对大家有所帮助!

通常情况下,Node.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_processcluster 不同,worker_threads 可以共享内存。 它们通过传输 ArrayBuffer 实例或共享 SharedArrayBuffer 实例来实现。

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

  • 它们运行具有多个线程的单个进程。

  • 每个线程执行一个事件循环。

  • 每个线程运行单个 JS 引擎实例。

  • 每个线程执行单个 Nodejs 实例。

worker_threads 如何工作

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

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

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

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));
}
登录后复制

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

worker_threads 具体使用

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

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

const { workerData, parentPort } = require('worker_threads')
parentPort.postMessage({ welcome: workerData })
登录后复制

创建主线程脚本文件main.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))
登录后复制

控制台命令行执行:

node main.js
登录后复制
登录后复制

输出:

{ welcome: 'hello worker threads' }
登录后复制

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);
    }
}
登录后复制

创建主线程脚本文件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");
登录后复制

控制台命令行执行:

node main.js
登录后复制
登录后复制

输出:

Execution in main thread
30th Fibonacci Result: 832040
It exited with code 0
登录后复制

main.js文件中,我们从类的实例创建一个工作线程,Worker正如我们在前面的示例中看到的那样。

为了得到结果,我们监听 3 个事件,

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

我们在最后一行main.js

console.log("Execution in main thread");
登录后复制

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

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

结论

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

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

思考

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

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

最后

以上就是可耐老鼠为你收集整理的聊聊Node.js + worker_threads如何实现多线程?(详解)的全部内容,希望文章能够帮你解决聊聊Node.js + worker_threads如何实现多线程?(详解)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错,欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(59)

评论列表共有 0 条评论

立即
投稿
返回
顶部