Node.js中如何同步获取Promise结果以实现串行编程？

这个需求完全可以实现，你之前遇到的CPU占用高问题，根源是用了轮询等待Promise的错误姿势——Node.js的异步非阻塞模型天生适合处理这类IO密集型的串行任务，根本不需要轮询或者模拟sleep。

一、先封装通用异步工具函数 #

把Linux命令、HTTP请求、MySQL查询分别封装成返回Promise的函数，统一用异步方式处理：

1. 执行Linux命令 #

借助child_process模块的exec方法，包装成Promise：

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

function execCmd(cmd) {
  return new Promise((resolve, reject) => {
    exec(cmd, (error, stdout, stderr) => {
      if (error) {
        reject(error);
        return;
      }
      resolve(stdout.trim());
    });
  });
}

2. 调用URL请求 #

用node-fetch（需通过npm install node-fetch安装）实现Promise化的HTTP请求：

const fetch = require('node-fetch');

async function fetchUrl(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) {
    throw new Error(`请求失败，状态码: ${response.status}`);
  }
  return await response.json(); // 可根据需求改为text()或其他格式
}

3. MySQL查询 #

使用mysql2/promise模块（原生支持Promise），先创建连接池再封装查询函数：

const mysql = require('mysql2/promise');

// 初始化连接池
const pool = mysql.createPool({
  host: 'localhost',
  user: '你的用户名',
  password: '你的密码',
  database: '目标数据库'
});

async function queryMysql(sql, params = []) {
  const [rows] = await pool.execute(sql, params);
  return rows;
}

二、串行执行依赖任务的正确方式 #

用async/await配合循环，或者Array.reduce实现串行执行，每一步都等待前一个任务完成后，再用其结果执行下一个任务——这种方式是非阻塞的，不会占用额外CPU：

方式1：async/await循环（适合动态生成任务场景） #

如果需要根据前一次执行结果决定下一个任务，用循环最直观：

async function runSerialTasks(initialData) {
  let currentResult = initialData;
  
  // 示例任务序列：先执行pwd，再用路径请求接口，最后用接口结果查数据库
  // 可根据业务逻辑动态生成任务列表
  const tasks = [
    () => execCmd('pwd'),
    (prevRes) => fetchUrl(`https://example.com/api?path=${encodeURIComponent(prevRes)}`),
    (prevRes) => queryMysql('SELECT * FROM operation_logs WHERE target_path = ?', [prevRes.data.path])
  ];
  
  for (const task of tasks) {
    currentResult = await task(currentResult);
    console.log('当前任务结果:', currentResult);
  }
  
  return currentResult;
}

// 启动执行
runSerialTasks(null)
  .then(finalResult => console.log('最终执行结果:', finalResult))
  .catch(err => console.error('执行出错:', err));

方式2：Array.reduce串行执行（适合固定任务列表场景） #

如果任务列表是固定的，用reduce串联Promise链更简洁：

const tasks = [
  () => execCmd('pwd'),
  (prevRes) => fetchUrl(`https://example.com/api?path=${encodeURIComponent(prevRes)}`),
  (prevRes) => queryMysql('SELECT * FROM operation_logs WHERE target_path = ?', [prevRes.data.path])
];

// 用reduce构建串行Promise链
tasks.reduce((promiseChain, currentTask) => {
  return promiseChain.then(prevResult => currentTask(prevResult));
}, Promise.resolve(null))
.then(finalResult => console.log('最终执行结果:', finalResult))
.catch(err => console.error('执行出错:', err));

三、为什么之前CPU占用高？ #

你之前用轮询等待Promise的方式，本质是在事件循环里做同步死循环检查状态，比如：

// 错误示例：同步轮询会直接拉满CPU
function waitPromise(promise) {
  let done = false;
  let result;
  promise.then(res => {
    result = res;
    done = true;
  });
  while (!done) {} // 这里是同步死循环，阻塞事件循环，CPU直接跑满
  return result;
}

这种写法完全违背了Node.js的异步非阻塞设计，正确的做法是用await或then()等待Promise完成，此时事件循环会处理其他任务，不会占用CPU资源。

四、上百次调用的性能保障 #

这些任务都是IO密集型（命令执行、网络请求、数据库查询），Node.js的事件循环可以高效处理这类异步操作，即使串行执行上百次，也不会出现CPU占用过高的问题——因为每一步等待IO时，事件循环处于空闲状态，不会消耗CPU。

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