Node.js(TypeScript)如何实现主进程不可序列化对象共享至工作进程？

这个问题我之前也碰到过——Node.js Cluster模块的进程间IPC通信依赖结构化克隆算法，没法直接传递不可序列化的对象（比如包含函数、循环引用或者自定义类实例的对象）。下面给你几个可行的解决方案，按推荐程度排序：

核心思路是：让主进程持有Foo实例，工作进程通过发送IPC消息请求主进程执行Foo的方法，主进程执行后把结果返回给工作进程。这样工作进程不需要持有实例本身，完美避开序列化问题。

TypeScript代码示例： #

主进程逻辑：

import cluster from 'cluster';
import os from 'os';
import { Foo } from './your-foo-module';

// Node.js v16+用isPrimary代替旧的isMaster
if (cluster.isPrimary) {
  // 主进程创建唯一的Foo实例
  const foo = new Foo();

  // 监听每个工作进程的消息
  cluster.on('fork', (worker) => {
    worker.on('message', async (msg) => {
      // 处理工作进程的方法调用请求
      if (msg.type === 'call_foo_method') {
        try {
          // 调用Foo的对应方法并获取结果
          const result = await foo[msg.methodName](...msg.args);
          // 把结果返回给发起请求的工作进程
          worker.send({
            type: 'foo_method_result',
            requestId: msg.requestId,
            data: result
          });
        } catch (error) {
          // 处理错误并返回
          worker.send({
            type: 'foo_method_result',
            requestId: msg.requestId,
            error: (error as Error).message
          });
        }
      }
    });
  });

  // 启动对应CPU核心数的工作进程
  for (let i = 0; i < os.cpus().length; i++) {
    cluster.fork();
  }
}

工作进程逻辑：

import cluster from 'cluster';
import { Foo } from './your-foo-module';

if (cluster.isWorker) {
  // 封装一个Foo代理类，模拟Foo的接口，内部通过IPC请求主进程
  class FooProxy implements Foo {
    private nextRequestId = 0;

    // 通用方法：发送IPC请求并等待结果
    private async callMethod<T>(methodName: keyof Foo, ...args: any[]): Promise<T> {
      const requestId = this.nextRequestId++;
      return new Promise((resolve, reject) => {
        // 发送请求到主进程
        process.send!({
          type: 'call_foo_method',
          requestId,
          methodName,
          args
        });

        // 监听主进程的响应
        const messageHandler = (response: any) => {
          if (response.type === 'foo_method_result' && response.requestId === requestId) {
            process.off('message', messageHandler);
            if (response.error) {
              reject(new Error(response.error));
            } else {
              resolve(response.data as T);
            }
          }
        };

        process.on('message', messageHandler);
      });
    }

    // 实现Foo的具体方法，让调用体验和直接用Foo一致
    async doSomething(arg1: string): Promise<string> {
      return this.callMethod<string>('doSomething', arg1);
    }

    anotherSyncMethod(): number {
      // 即使是同步方法，也要用Promise包装（因为IPC是异步的）
      return this.callMethod<number>('anotherSyncMethod');
    }
  }

  // 工作进程中使用FooProxy代替Foo
  const foo = new FooProxy();

  // 示例调用
  foo.doSomething('test input').then(result => {
    console.log('工作进程获取到结果:', result);
  });
}

为什么这个方案好用？ #

• 完全兼容现有Cluster架构，不需要大改代码
• 天然隔离进程间的状态，避免多线程安全问题
• 可以轻松扩展，比如添加超时处理、请求队列等

如果你的场景对IPC性能要求很高，可以考虑用Node.js的worker_threads模块代替Cluster。Worker Threads是同一进程内的线程，内存可以部分共享，IPC开销比Cluster的进程间通信小很多。

核心思路和代理模式类似：主线程持有Foo实例，工作线程通过消息请求主线程执行方法。

TypeScript代码示例： #

import { Worker, isMainThread, parentPort } from 'worker_threads';
import { Foo } from './your-foo-module';

if (isMainThread) {
  const foo = new Foo();
  // 启动工作线程
  const worker = new Worker(__filename);

  worker.on('message', async (msg) => {
    if (msg.type === 'call_foo') {
      try {
        const result = await foo[msg.method](...msg.args);
        worker.postMessage({
          type: 'foo_result',
          id: msg.id,
          result
        });
      } catch (err) {
        worker.postMessage({
          type: 'foo_result',
          id: msg.id,
          error: (err as Error).message
        });
      }
    }
  });
} else {
  // 工作线程的代理函数
  async function callFoo<T>(method: keyof Foo, ...args: any[]): Promise<T> {
    return new Promise((resolve, reject) => {
      const id = Date.now() + Math.random();
      parentPort!.postMessage({ type: 'call_foo', id, method, args });

      const handler = (msg: any) => {
        if (msg.type === 'foo_result' && msg.id === id) {
          parentPort!.off('message', handler);
          msg.error ? reject(new Error(msg.error)) : resolve(msg.result as T);
        }
      };

      parentPort!.on('message', handler);
    });
  }

  // 使用示例
  callFoo<string>('doSomething', 'test').then(console.log);
}

注意点： #

• Worker Threads共享进程内存，要注意线程安全（比如如果Foo有可变状态，需要加锁）
• 不是所有场景都适合迁移，比如如果你的代码依赖Cluster的进程隔离特性，还是用方案1更稳妥

为了让TypeScript更好地发挥作用，你可以让FooProxy严格实现Foo的接口，这样调用时代智能提示和类型检查都会生效，和直接使用Foo没有区别。比如：

// 先定义Foo的接口
interface IFoo {
  doSomething(arg: string): Promise<string>;
  anotherSyncMethod(): number;
}

// Foo类实现这个接口
class Foo implements IFoo {
  async doSomething(arg: string): Promise<string> {
    return `处理结果：${arg}`;
  }

  anotherSyncMethod(): number {
    return 42;
  }
}

// FooProxy也实现IFoo
class FooProxy implements IFoo {
  // ... 之前的callMethod方法 ...

  async doSomething(arg: string): Promise<string> {
    return this.callMethod<string>('doSomething', arg);
  }

  anotherSyncMethod(): number {
    return this.callMethod<number>('anotherSyncMethod');
  }
}

这样在工作进程中使用FooProxy时，TypeScript会自动检查方法参数和返回值类型，减少错误。

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