如何在Express.js接口中不借助外部任务队列/消息代理运行后台长耗时函数？

以下是几种无需依赖RabbitMQ等任务队列工具，在Express接口中后台运行耗时函数的方法：

1. 直接异步调用（仅适用于IO密集型任务） #

如果你的myLongRunningFunction是IO密集型（比如数据库查询、文件读写、网络请求），可以直接调用，但要务必捕获内部错误，避免未处理的异常导致整个Node进程崩溃：

function myLongRunningFunction(city, country) {
  // 模拟耗时IO操作
  setTimeout(() => {
    try {
      // 这里执行耗时任务，比如查询数据库、处理文件
      console.log(`处理任务：${city}, ${country}`);
    } catch (err) {
      // 捕获并处理任务内部错误
      console.error('后台任务出错:', err);
    }
  }, 0);
}

var myApi = async function(req, res) {
  try {
    let { city, country } = req.body;
    // 直接调用，任务会在事件循环中异步执行
    myLongRunningFunction(city, country);
    res.json({ success: true });
  } catch(error) {
    res.json({ success: false, message: error.message });
  }
}

注意：如果是CPU密集型任务，这种方法会阻塞事件循环，影响接口的响应速度，不建议使用。

2. 使用setImmediate延迟执行 #

setImmediate会把任务放到事件循环的check阶段执行，确保接口先响应客户端，再处理后台任务：

function myLongRunningFunction(city, country) {
  try {
    // CPU或IO密集型任务逻辑
    console.log(`处理任务：${city}, ${country}`);
  } catch (err) {
    console.error('后台任务出错:', err);
  }
}

var myApi = async function(req, res) {
  try {
    let { city, country } = req.body;
    // 延迟到事件循环下一轮执行
    setImmediate(() => myLongRunningFunction(city, country));
    res.json({ success: true });
  } catch(error) {
    res.json({ success: false, message: error.message });
  }
}

3. 使用子进程（child_process）处理CPU密集型任务 #

Node.js是单线程的，CPU密集型任务会阻塞主线程，用子进程可以把任务放到独立进程中执行，充分利用多核CPU：

const { fork } = require('child_process');

var myApi = async function(req, res) {
  try {
    let { city, country } = req.body;
    // 创建子进程，执行单独的任务文件
    const child = fork('./long-running-task.js');
    // 向子进程发送参数
    child.send({ city, country });
    // 监听子进程的消息或错误
    child.on('message', (result) => {
      console.log('任务完成:', result);
    });
    child.on('error', (err) => {
      console.error('子进程出错:', err);
    });
    res.json({ success: true });
  } catch(error) {
    res.json({ success: false, message: error.message });
  }
}

对应的long-running-task.js文件：

process.on('message', (payload) => {
  const { city, country } = payload;
  // 执行CPU密集型任务
  let result = heavyComputation(city, country);
  // 向主进程发送结果
  process.send(result);
  // 任务完成后退出子进程
  process.exit();
});

function heavyComputation(city, country) {
  // 模拟耗时计算
  let sum = 0;
  for (let i = 0; i < 1e9; i++) {
    sum += i;
  }
  return { city, country, sum };
}

4. 使用Worker线程（worker_threads） #

Worker线程是Node.js 10.5.0+提供的轻量级多线程方案，比子进程更节省资源，适合CPU密集型任务：

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

var myApi = async function(req, res) {
  try {
    let { city, country } = req.body;
    // 创建Worker线程
    const worker = new Worker('./worker-task.js', {
      workerData: { city, country }
    });
    // 监听Worker的结果和错误
    worker.on('message', (result) => {
      console.log('任务完成:', result);
    });
    worker.on('error', (err) => {
      console.error('Worker出错:', err);
    });
    worker.on('exit', (code) => {
      if (code !== 0) {
        console.error(`Worker退出，代码：${code}`);
      }
    });
    res.json({ success: true });
  } catch(error) {
    res.json({ success: false, message: error.message });
  }
}

对应的worker-task.js文件：

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

// 执行CPU密集型任务
let result = heavyComputation(city, country);
// 向主线程发送结果
parentPort.postMessage(result);

function heavyComputation(city, country) {
  let sum = 0;
  for (let i = 0; i < 1e9; i++) {
    sum += i;
  }
  return { city, country, sum };
}

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