Node.js类转Worker的高效技巧

在IT行业这个发展更新速度很快的行业，只有不停止的学习，才不会被行业所淘汰。如果你是文章学习者，那么本文《Node.js 类转 Worker 的实用方法》就很适合你！本篇内容主要包括##content_title##，希望对大家的知识积累有所帮助，助力实战开发！

本文介绍如何利用 Node.js 的 worker_threads 模块，将耗时的 Node.js 类自动转换为在独立线程中运行的 Worker，从而避免阻塞主线程。通过提供的 WrapWorker 函数，你可以轻松地将任何类及其方法暴露给 Worker 线程，实现并发执行，提升应用程序的性能和响应速度。本文将详细讲解 WrapWorker 函数的实现原理和使用方法，并提供示例代码，帮助你快速上手。

利用 worker_threads 实现多线程

Node.js 默认是单线程的，这意味着所有的 JavaScript 代码都在同一个线程中执行。当遇到 CPU 密集型任务时，单线程模型可能会导致主线程阻塞，影响应用程序的响应速度。为了解决这个问题，Node.js 提供了 worker_threads 模块，允许开发者创建多个线程，并发执行任务。

封装 WrapWorker 函数

为了简化将类转换为 Worker 的过程，我们可以封装一个 WrapWorker 函数。该函数接收一个类和一个构造函数参数数组作为输入，返回一个代理对象，该代理对象的方法可以在 Worker 线程中执行。

以下是 WrapWorker 函数的实现代码：

// wrap-worker.js
const { Worker } = require('worker_threads');

function WrapWorker(OBJECT, OBJECT_ARGS) {
  if (require('worker_threads').isMainThread) {
    const workerCode = `
      const { parentPort, workerData } = require('worker_threads');
      const OBJECT = ${OBJECT.toString()};

      const instance = new OBJECT(...workerData);

      parentPort.on('message', async (data) => {
        try {
          const method = instance[data.method];
          if (typeof method === 'function') {
            const response = await method.apply(instance, data.arguments);
            parentPort.postMessage({ rid: data.rid, valid: true, response });
          } else {
            parentPort.postMessage({ rid: data.rid, valid: false });
          }
        } catch (error) {
          parentPort.postMessage({ rid: data.rid, valid: false });
        }
      });
    `;

    const instance = new Worker(workerCode, { eval: true, workerData: OBJECT_ARGS });

    const methodsProxy = {};
    const methods = Object.getOwnPropertyNames(OBJECT.prototype);

    let rid = 0;
    const requests = {};
    for (const methodId of methods) {
      methodsProxy[methodId] = (...args) =>
        new Promise((resolve, reject) => {
          rid++;
          requests[rid] = { resolve, reject };
          instance.postMessage({ method: methodId, arguments: args, rid });
        });
    }

    instance.on('message', (data) => {
      const request = requests[data.rid];
      if (request) {
        if (data.valid) {
          request.resolve(data.response);
        } else {
          request.reject();
        }
        delete requests[data.rid];
      }
    });

    return methodsProxy;
  }
}

module.exports = WrapWorker;

代码解释：

1. WrapWorker(OBJECT, OBJECT_ARGS) 函数： 接收要转换为 Worker 的类 OBJECT 和构造函数的参数数组 OBJECT_ARGS 作为输入。
2. require('worker_threads').isMainThread 检查： 确保代码只在主线程中执行。
3. workerCode 字符串： 包含了 Worker 线程的代码。它将 OBJECT 转换为字符串，并在 Worker 线程中创建一个实例。
4. parentPort.on('message', ...)： 监听来自主线程的消息。当收到消息时，它会尝试调用实例的相应方法，并将结果返回给主线程。
5. new Worker(workerCode, { eval: true, workerData: OBJECT_ARGS })： 创建一个新的 Worker 线程，并将 workerCode 作为代码执行。 eval: true 允许执行字符串形式的代码。 workerData: OBJECT_ARGS 将构造函数参数传递给 Worker 线程。
6. methodsProxy 对象： 用于存储代理方法。
7. Object.getOwnPropertyNames(OBJECT.prototype)： 获取类原型上的所有方法名。
8. methodsProxy[methodId] = (...args) => ...： 为每个方法创建一个代理函数。当调用代理函数时，它会将方法名和参数发送给 Worker 线程，并返回一个 Promise。
9. instance.on('message', ...)： 监听来自 Worker 线程的消息。当收到消息时，它会解析 Promise，并将结果返回给调用方。

使用示例

class RunInWorker {

  constructor (starta, startb) {
    this.sum = starta + startb;
  }

  addSync(a, b) {
    return a + b + this.sum;
  }

  async addAsync(a, b) {
    await (new Promise((resolve) => { setTimeout(resolve, 3000); }));
    return a + b + this.sum;
  }

}

/** @type {\RunInWorker} */
let worker = new require('./wrap-worker.js')(RunInWorker, [5, 5]);

(async () => {
  console.log(worker);
  console.log(await worker.addSync(3, 4), 'should be', 17);
  console.log(await worker.addAsync(3, 8), 'should be', 21);
})();

使用步骤：

1. 引入 wrap-worker.js 模块。
2. 调用 WrapWorker 函数，传入要转换为 Worker 的类和构造函数参数。
3. 使用返回的代理对象调用类的方法。

注意事项

• 传递给 Worker 线程的参数和返回值必须是可序列化的。
• Worker 线程无法访问主线程的变量和函数，除非通过消息传递。
• 调试 Worker 线程的代码可能比调试主线程的代码更复杂。

总结

通过 worker_threads 模块和 WrapWorker 函数，我们可以轻松地将 Node.js 类转换为在独立线程中运行的 Worker，从而提高应用程序的性能和响应速度。这种方法特别适用于 CPU 密集型任务，可以有效地避免阻塞主线程。希望本文能够帮助你更好地理解和使用 Node.js 的多线程功能。

理论要掌握，实操不能落！以上关于《Node.js类转Worker的高效技巧》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！