如何自动将Node.js类转为Worker线程？现有实现是否最优？

我在Node.js服务器上有一项耗时任务，想要测试它在独立线程中运行的性能表现。希望无需手动编写所有代码就能将类暴露到Worker线程中，请问Node.js是否有内置的函数或模块可以实现该功能？

我目前通过将类转为字符串的方式动态创建Worker，但认为这并非最佳方案，相关代码示例如下：

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

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

function WrapWorker(OBJECT, OBJECT_ARGS) {

  if (isMainThread) {

    let workerCode = `
const { parentPort, workerData } = require('worker_threads');

let OBJECT = ` + OBJECT.toString() + `

let INSTANCE = new OBJECT(...workerData);

parentPort.on('message', async function (data) {
  if (data.method) {
    let method = INSTANCE[data.method];
    if (typeof method === 'function') {
      let response;
      if (method.constructor.name === 'AsyncFunction') response = await method.apply(INSTANCE, data.arguments);
      else response = method.apply(INSTANCE, data.arguments);
      parentPort.postMessage({ rid: data.rid, valid: 1, response: response });
    } else {
      parentPort.postMessage({ rid: data.rid, valid: 0 });
    }
  }
});`;

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

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

    let rid = 0;
    let requests = [];
    for (let mid in methods) {
      let methodId = methods[mid];
      methodsProxy[methodId] = function () {
        return new Promise((resolve, reject) => {
          rid++;
          requests[rid] = { resolve: resolve, reject: reject };
          instance.postMessage({ method: methodId, arguments: Array.from(arguments), rid: rid });
        });
      };
    }

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

    return methodsProxy;

  }

}

module.exports = WrapWorker;

Node.js没有直接内置能自动将类完整暴露到Worker线程的函数或模块，但可以基于worker_threads模块实现更优雅的方案，避免将类转为字符串的操作：

优化方案：拆分Worker文件 #

将业务类、Worker逻辑、主进程封装拆分为独立文件，结构更清晰且无安全风险：

1. 业务类文件（run-in-worker.js）

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

module.exports = RunInWorker;

2. Worker处理文件（worker-handler.js）

const { parentPort, workerData } = require('worker_threads');
const RunInWorker = require('./run-in-worker');

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

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

3. 主进程封装（wrap-worker.js）

const { Worker, isMainThread } = require('worker_threads');

function WrapWorker(Class, args) {
  if (!isMainThread) return;

  const worker = new Worker('./worker-handler.js', { workerData: args });
  const methods = Object.getOwnPropertyNames(Class.prototype);
  const requests = new Map();
  let rid = 0;

  worker.on('message', (data) => {
    const req = requests.get(data.rid);
    if (req) {
      data.valid ? req.resolve(data.response) : req.reject(data.error || '无效方法');
      requests.delete(data.rid);
    }
  });

  const proxy = {};
  for (const method of methods) {
    proxy[method] = (...args) => new Promise((resolve, reject) => {
      rid++;
      requests.set(rid, { resolve, reject });
      worker.postMessage({ method, arguments: args, rid });
    });
  }

  return proxy;
}

module.exports = WrapWorker;

4. 主进程调用

const WrapWorker = require('./wrap-worker');
const RunInWorker = require('./run-in-worker');

/** @type {RunInWorker} */
const worker = WrapWorker(RunInWorker, [5, 5]);

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

方案优势 #

• 避免eval和字符串拼接代码带来的安全风险与维护难题
• 代码职责分离，业务类、Worker逻辑、主进程封装独立，便于调试扩展
• 天然支持类的依赖引入，无需额外处理依赖问题

内容的提问来源于stack exchange，提问作者KeySee