本文介绍如何利用 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;代码解释：
- WrapWorker(OBJECT, OBJECT_ARGS) 函数： 接收要转换为 Worker 的类 OBJECT 和构造函数的参数数组 OBJECT_ARGS 作为输入。
- require('worker_threads').isMainThread 检查： 确保代码只在主线程中执行。
- workerCode 字符串： 包含了 Worker 线程的代码。它将 OBJECT 转换为字符串，并在 Worker 线程中创建一个实例。
- parentPort.on('message', ...)： 监听来自主线程的消息。当收到消息时，它会尝试调用实例的相应方法，并将结果返回给主线程。
- new Worker(workerCode, { eval: true, workerData: OBJECT_ARGS })： 创建一个新的 Worker 线程，并将 workerCode 作为代码执行。 eval: true 允许执行字符串形式的代码。 workerData: OBJECT_ARGS 将构造函数参数传递给 Worker 线程。
- methodsProxy 对象： 用于存储代理方法。
- Object.getOwnPropertyNames(OBJECT.prototype)： 获取类原型上的所有方法名。
- methodsProxy[methodId] = (...args) => ...： 为每个方法创建一个代理函数。当调用代理函数时，它会将方法名和参数发送给 Worker 线程，并返回一个 Promise。
- 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);
})();使用步骤：
- 引入 wrap-worker.js 模块。
- 调用 WrapWorker 函数，传入要转换为 Worker 的类和构造函数参数。
- 使用返回的代理对象调用类的方法。
注意事项
- 传递给 Worker 线程的参数和返回值必须是可序列化的。
- Worker 线程无法访问主线程的变量和函数，除非通过消息传递。
- 调试 Worker 线程的代码可能比调试主线程的代码更复杂。
总结
通过 worker_threads 模块和 WrapWorker 函数，我们可以轻松地将 Node.js 类转换为在独立线程中运行的 Worker，从而提高应用程序的性能和响应速度。这种方法特别适用于 CPU 密集型任务，可以有效地避免阻塞主线程。希望本文能够帮助你更好地理解和使用 Node.js 的多线程功能。
