如何终止vm.runInNewContext返回的嵌套Promise执行链？

你的问题核心在于：Node.js的vm模块只能管控同步代码的执行时长，而异步Promise（尤其是嵌套递归的）会脱离vm的管控，在事件循环中后台持续执行——哪怕用Promise.race拿到了超时结果，这些异步逻辑依然会占用资源，最终导致栈溢出。

为什么原有方案无效？ #

• vm.Script.runInNewContext的timeout选项只约束脚本的同步执行阶段：当脚本里的同步代码跑完，runInNewContext就返回了，后续的异步Promise回调是在Node.js的事件循环中执行，vm根本管不到。
• Promise.race只是“谁先完成就返回谁的结果”，并不会终止另一个Promise链的执行——嵌套的递归Promise依然会在后台不断调用，直到栈溢出。

可靠解决方案：用Worker Threads隔离执行环境 #

要彻底终止所有执行（包括嵌套Promise），唯一可靠的方式是把沙箱代码放到独立的线程中执行，超时时直接终止整个线程。Node.js的worker_threads模块就是干这个的，它能提供轻量的线程隔离，且支持强制终止。

步骤1：创建Worker脚本（sandbox-worker.js）

这个脚本负责在沙箱中执行用户代码，并把结果返回给主线程：

const vm = require('vm');
const { parentPort, workerData } = require('worker_threads');

try {
  const { code, sandbox } = workerData;
  // 构建和你原有逻辑一致的执行脚本
  const scriptContent = `"use strict"; this.result = (async () => { ${code} })();`;
  const script = new vm.Script(scriptContent);
  
  // 执行脚本并获取Promise结果
  const resultPromise = script.runInNewContext(sandbox, { displayErrors: true });
  
  // 把执行结果发送回主线程
  Promise.resolve(resultPromise)
    .then(res => parentPort.postMessage({ type: 'success', data: res }))
    .catch(err => parentPort.postMessage({ type: 'error', data: err.stack || err.message }));
} catch (err) {
  parentPort.postMessage({ type: 'error', data: err.stack || err.message });
}

步骤2：主线程执行函数

主线程负责创建Worker、设置超时、监听结果，超时时直接终止Worker：

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

async function executeInSandbox(code, sandbox, timeoutMs = 20000) {
  return new Promise((resolve, reject) => {
    // 创建Worker并传递执行所需的参数
    const worker = new Worker('./sandbox-worker.js', {
      workerData: { code, sandbox }
    });

    // 设置超时定时器
    const timeoutTimer = setTimeout(() => {
      // 强制终止Worker，所有代码立即停止执行
      worker.terminate();
      reject(new Error(`Execution timed out after ${timeoutMs}ms`));
    }, timeoutMs);

    // 监听Worker返回的结果
    worker.on('message', msg => {
      clearTimeout(timeoutTimer);
      worker.unref(); // 允许Worker正常退出
      if (msg.type === 'success') {
        resolve(msg.data);
      } else {
        reject(new Error(msg.data));
      }
    });

    // 监听Worker执行错误
    worker.on('error', err => {
      clearTimeout(timeoutTimer);
      worker.unref();
      reject(err);
    });

    // 监听Worker异常退出
    worker.on('exit', code => {
      clearTimeout(timeoutTimer);
      if (code !== 0) {
        reject(new Error(`Worker exited with code ${code}`));
      }
    });
  });
}

// 使用示例
(async () => {
  try {
    const result = await executeInSandbox(`
      // 模拟嵌套递归的Promise代码
      async function deepRecursion(count) {
        if (count <= 0) return "Completed";
        await Promise.resolve();
        return deepRecursion(count - 1);
      }
      return deepRecursion(100000);
    `, {}, 2000); // 设置2秒超时
    console.log(result);
  } catch (err) {
    console.error(err.message); // 会输出超时错误，且Worker被终止，不会栈溢出
  }
})();

关键优势 #

• 彻底终止执行：调用worker.terminate()会立即杀死整个线程，所有正在运行的代码（包括嵌套Promise、递归调用）都会被停止，从根源上避免栈溢出和资源泄漏。
• 线程隔离：Worker的执行环境和主线程完全隔离，不会影响主线程的正常运行。

替代方案（旧Node.js版本） #

如果你的Node.js版本低于10（不支持Worker Threads），可以用child_process.fork创建子进程，超时时调用child.kill()终止进程，原理和Worker一致，只是进程比线程稍重一些。

为什么不推荐在vm里直接中断？ #

如果尝试在沙箱中注入中断信号（比如一个全局变量，让用户代码定期检查），这要求用户代码必须配合你的逻辑——但你的场景是“自定义代码可能是任意的”，所以这个方案不可靠，无法覆盖所有情况。

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