Node.js主线程与工作线程中静态Map引发进程无限重启问题排查

我完全懂你这种抓不到错误信息、看着进程无限重启的抓狂感——明明代码没做什么复杂操作，就因为碰了个静态Map，程序就陷入死循环重启，连错误日志都不给，排查起来确实像摸黑走路。咱们一步步拆解这个问题，找到根源和解决办法。

问题触发的核心现象 #

你提到的情况非常典型：只要baseworker.ts里的代码引用了Main.baseWorkerMap（哪怕不调用函数），进程就会无限重启，内存持续上涨，只能通过关闭终端终止。而注释掉这个引用后，一切正常，但又无法完成Worker的注册逻辑。

根本原因：循环依赖+递归线程创建 #

这种问题的本质是Node.js Worker线程模块的循环依赖+递归触发线程实例化，具体来说：

1. 模块循环依赖：主线程的Main类引入了BaseWorker，而BaseWorker又引入了Main（为了访问静态Map），形成了闭环依赖。
2. 递归线程创建：当Worker线程启动加载baseworker.ts时，它会执行模块的import逻辑——也就是引入Main类。而Main类的模块初始化过程中，又包含了创建Worker的代码（invokeWorker）。这就导致：Worker启动→加载Main→Main创建新Worker→新Worker再加载Main→无限循环，最终进程因递归创建线程而不断重启。

哪怕你没有主动调用registerWorkerName，只要baseworker.ts里存在Main.baseWorkerMap的引用，就会触发Main模块的加载，进而触发递归创建Worker的逻辑。

解决方案：打破循环依赖+隔离线程依赖链 #

1. 拆分静态Map到独立模块（核心） #

把原来Main类里的baseWorkerMap拆到一个不依赖Worker或主线程核心逻辑的独立模块中，彻底打破循环依赖：

// worker-registry.ts
import { BaseWorker } from './baseworker';

// 专门负责Worker实例的注册，不依赖任何创建Worker的代码
export class WorkerRegistry {
  static baseWorkerMap: Map<string, BaseWorker> = new Map<string, BaseWorker>();
}

2. 调整Main类，改用独立Registry #

在main.ts里移除自己的静态Map，转而引用新的WorkerRegistry：

// main.ts 调整部分
import path from 'path';
import { Worker } from 'node:worker_threads';
import { BaseWorker } from './baseworker';
import { WorkerRegistry } from './worker-registry'; // 新增引入

export class Main {
  static readonly baseWorkerPath = path.resolve(__dirname, 'baseworker.js');
  static readonly baseWorkerSource = path.resolve(__dirname, 'baseworker.ts');
  static readonly worker2Path = path.resolve(__dirname, 'worker2.js');
  static readonly worker2Source = path.resolve(__dirname, 'worker2.ts');

  // 移除原来的baseWorkerMap，改用WorkerRegistry的Map
  // static baseWorkerMap: Map<string, BaseWorker> = new Map<string, BaseWorker>();

  static async invokeWorker(workernameParm: string, workerPathParm: string, workerSourceParm: string): Promise<void> {
    // 原invokeWorker逻辑保持不变...
  }
}

Main.invokeWorker('baseworker', Main.baseWorkerPath, Main.baseWorkerSource).then ( 
  () => Main.invokeWorker('worker2', Main.worker2Path, Main.worker2Source).then ( 
    () => { 
      console.log();
      console.log(`all done`);
      console.log();
    } 
  ) 
)

3. 调整BaseWorker，引用独立Registry而非Main #

在baseworker.ts里，把对Main的引用换成WorkerRegistry，同时调整注册函数：

// baseworker.ts 调整部分
import { isMainThread } from 'node:worker_threads';
// 移除import { Main } from './main';
import { WorkerRegistry } from './worker-registry'; // 新增引入

export class BaseWorker {
  constructor(readonly name: string) {
    console.log(`finishing construction for class BaseWorker '${name}'`);
  }
}

export function initWorker<T extends BaseWorker>(isMainThreadParm: boolean, workername: string, instance: T) {
  checkIfWorkerThread(isMainThreadParm, workername);
  console.log();
  console.log(`Executing code in worker '${workername}'`);
  registerAndListRegisteredWorkerNames(workername, instance); // 现在可以安全启用
}

function registerAndListRegisteredWorkerNames<T extends BaseWorker>(workernameParm: string, instanceParm: T): void {
  registerWorkerName<T>(workernameParm, instanceParm);
  listRegisteredNames();
}

function registerWorkerName<T extends BaseWorker>(workernameParm: string, instanceParm: T): void {
  // 改用WorkerRegistry的Map，而非Main的
  if (!WorkerRegistry.baseWorkerMap.get(workernameParm)) {
    WorkerRegistry.baseWorkerMap.set(workernameParm, instanceParm);
  }
}

function listRegisteredNames(): void {
  console.log();
  console.log(`Current list of registered worker names:`);
  // 同样改用WorkerRegistry的Map
  const registeredWorkerNames = WorkerRegistry.baseWorkerMap.keys();
  let nextRegisteredName = registeredWorkerNames.next();
  while (!nextRegisteredName.done) {
    console.log(` ${nextRegisteredName.value}`);
    nextRegisteredName = registeredWorkerNames.next();
  }
  console.log();
}

function checkIfWorkerThread(isMainThreadParm: boolean, workernameParm: string): void {
  if (isMainThreadParm) {
    const errorMessage = `ERROR: ${workernameParm} is running in main thread, this should be a worker thread`;
    throw new Error(errorMessage);
  }
}

// 最后，确保只有在Worker线程环境下才执行初始化逻辑
if (!isMainThread) {
  const workername = 'baseWorker'
  console.log(`Starting code in worker '${workername}'`);
  initWorker<BaseWorker>(isMainThread, workername, new BaseWorker(workername));
}

4. 验证效果 #

现在你可以把baseworker.ts里的注册函数全部取消注释，运行程序：

• 进程不会再无限重启
• Worker的注册逻辑会正常执行，WorkerRegistry.baseWorkerMap会正确记录Worker实例
• 主线程和Worker线程的依赖链被彻底打破，不会再触发递归创建Worker的逻辑

额外排查小技巧 #

1. 检测循环依赖：可以用工具比如depcheck或madge来自动检测项目中的循环模块依赖，命令行执行npx madge --circular src就能直观看到依赖链。
2. 线程环境隔离：Worker线程的代码里，绝对不要引入主线程中包含Worker创建逻辑的模块——这是避免递归创建的关键。
3. 添加调试日志：在Main.invokeWorker和BaseWorker.initWorker的开头加console.log，比如console.log('触发invokeWorker:', workernameParm)，就能快速发现是不是有重复触发的情况。

这种问题确实容易踩坑，因为Node.js的模块加载机制在Worker线程里的表现和主线程略有不同，加上循环依赖的隐蔽性，很容易让人摸不着头脑。打破循环依赖+隔离线程间的模块依赖，基本就能解决这类问题。

内容来源于stack exchange