使用 Node.js Workers 自动转换类到独立线程-js教程-PHP中文网

使用 Node.js Workers 自动转换类到独立线程

DDD

发布： 2025-08-13 18:16:51

原创

432人浏览过

使用 node.js workers 自动转换类到独立线程

本文档介绍如何利用 Node.js 的 worker_threads 模块，将耗时的 JavaScript 类自动转换为在独立线程中运行，从而避免阻塞主线程。通过封装类，我们可以方便地在 worker 线程中执行方法，并通过消息传递机制与主线程进行通信，实现并发执行。这对于需要执行大量计算或 I/O 操作的 Node.js 应用来说至关重要，可以显著提升应用的响应速度和整体性能。本文将提供一个 WrapWorker 函数，它可以自动将一个类转换为一个 worker，无需手动编写大量的 worker 代码。

自动 Worker 封装函数

以下是一个名为 WrapWorker 的函数，它接受一个类定义和一个构造函数参数数组，并在 worker 线程中实例化该类。主线程可以通过代理对象调用 worker 线程中的方法。

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

function WrapWorker(OBJECT, OBJECT_ARGS) {
  if (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;

登录后复制

代码解释：

WrapWorker(OBJECT, OBJECT_ARGS): 此函数接收两个参数：
- OBJECT: 要转换为 worker 的类定义。
- OBJECT_ARGS: 传递给类构造函数的参数数组。
isMainThread: 检查当前是否在主线程中运行。如果不是主线程，则该函数不执行任何操作。
workerCode: 包含在 worker 线程中执行的 JavaScript 代码的字符串。
- OBJECT = ${OBJECT.toString()}: 将类的字符串表示形式嵌入到 worker 代码中。
- instance = new OBJECT(...workerData): 使用传递的构造函数参数实例化该类。
- parentPort.on('message', ...): 设置一个消息处理程序，用于接收来自主线程的消息。
  - 当收到消息时，它会尝试调用类实例上的指定方法。
  - 如果方法存在且是一个函数，它将被调用，并且结果将通过消息传递回主线程。
  - 如果方法不存在或不是一个函数，则会向主线程发送一个错误消息。
  - 使用 try...catch 块来处理 worker 线程中可能发生的任何错误，并向主线程发送错误消息。
new Worker(workerCode, { eval: true, workerData: OBJECT_ARGS }): 创建一个新的 worker 线程，并使用提供的代码和数据对其进行初始化。 eval: true 允许在 worker 中执行字符串形式的代码。
methodsProxy: 一个空对象，用于存储将在主线程中使用的代理方法。
Object.getOwnPropertyNames(OBJECT.prototype): 获取类原型上的所有属性名称（包括方法）。
循环遍历方法名称: 对于类原型上的每个方法，创建一个代理函数，该函数：
- 生成一个唯一的请求 ID (rid).
- 创建一个新的 Promise，该 Promise 将在 worker 线程完成执行时被解析或拒绝。
- 将请求 ID、参数和方法名称发送到 worker 线程。
- 将 Promise 解析和拒绝函数存储在 requests 对象中，以便稍后使用。
instance.on('message', ...): 设置一个消息处理程序，用于接收来自 worker 线程的消息。
- 当收到消息时，它会检索相应的请求对象。
- 如果请求存在，它会根据消息中的 valid 标志解析或拒绝 Promise。
- 然后从 requests 对象中删除请求对象。
return methodsProxy: 返回包含代理方法的对象。

使用示例

以下是如何使用 WrapWorker 函数的示例：

Swapface人脸交换

一款创建逼真人脸交换的AI换脸工具

查看详情

// my-class.js
class MyClass {
  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;
  }
}

module.exports = MyClass;

登录后复制

// index.js
const RunInWorker = require('./my-class.js');
const 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);
})();

登录后复制

在这个例子中，MyClass 定义了一个简单的类，它有一个构造函数和两个方法：addSync 和 addAsync。 index.js 文件使用 WrapWorker 函数将 MyClass 转换为一个 worker。然后，它调用 worker 线程中的 addSync 和 addAsync 方法，并将结果打印到控制台。

注意事项

序列化: 传递给 worker 线程的参数和从 worker 线程返回的值必须是可序列化的。这意味着它们必须是基本类型（如数字、字符串、布尔值）或可以转换为 JSON 的对象。
错误处理: 在 worker 线程中发生的错误不会自动传播到主线程。需要在 worker 线程中捕获错误，并将它们传递回主线程。WrapWorker 函数已经包含了基本的错误处理机制，可以将错误信息传递回主线程。
性能: 创建和销毁 worker 线程的开销可能很高。对于非常短的任务，使用 worker 线程可能适得其反。
调试: 调试 worker 线程可能比较困难。Node.js 提供了一些工具来帮助调试 worker 线程，例如 --inspect-brk 标志。

总结

WrapWorker 函数提供了一种方便的方法，可以将 Node.js 类自动转换为在独立线程中运行。这可以帮助您提高 Node.js 应用程序的性能和响应能力。使用 worker_threads 模块时，请务必考虑上述注意事项，以确保您的应用程序能够正常运行。通过合理地利用 worker 线程，可以充分发挥多核 CPU 的优势，提升应用的整体性能。

以上就是使用 Node.js Workers 自动转换类到独立线程的详细内容，更多请关注php中文网其它相关文章！