如何在Node.js中控制Oracle数据库的请求并发数量？

嘿，这个问题我太熟了——你遇到的就是典型的数据库并发请求过载问题！当你直接在.map()里发起异步查询时，相当于一口气给数据库B发了1000个请求，远远超过了它能同时处理的数量（不管是连接池上限还是数据库本身的并发限制），所以大部分请求直接被打回来了。下面给你几个实用的解决方案，按优先级排序：

1. 优先用跨库关联查询（最优解） #

如果你的数据库环境支持跨库访问（比如Oracle的DBLink），直接在数据库层面完成关联查询是最高效的，完全避免应用层的并发问题。

比如你可以在数据库A上创建一个指向数据库B的DBLink，然后写一条JOIN查询：

const oracledb = require('oracledb');

async function getBillsWithCustomers(targetDate) {
  let connection;
  try {
    // 连接到数据库A（已配置DBLink指向数据库B）
    connection = await oracledb.getConnection({
      user: 'db_a_user',
      password: 'db_a_pwd',
      connectString: 'db_a_connect_string'
    });
    
    const result = await connection.execute(`
      SELECT b.*, c.*
      FROM bills b
      LEFT JOIN db_b_link.customers c ON b.bill_id = c.bill_id
      WHERE b.publish_date = :targetDate
    `, [targetDate]);
    
    return result.rows.map(row => ({
      // 这里可以把数据库返回的行转换成你需要的对象结构
      billId: row[0],
      publishDate: row[1],
      customerName: row[3],
      // ...其他字段
    }));
  } catch (err) {
    console.error('查询失败:', err);
    throw err;
  } finally {
    if (connection) {
      await connection.close();
    }
  }
}

这种方式把压力交给了数据库，它会用最优的执行计划处理关联，性能比应用层循环查询好太多。

2. 控制并发数+分批处理（无跨库权限时用） #

如果没法用跨库查询，那就要限制同时发起的请求数量，配合连接池一起用。

第一步：配置合理的连接池 #

先给数据库B配置一个连接池，设置合适的最大连接数（比如20-50，根据数据库允许的并发数调整）：

async function initDbBPool() {
  await oracledb.createPool({
    user: 'db_b_user',
    password: 'db_b_pwd',
    connectString: 'db_b_connect_string',
    poolMax: 20, // 关键：限制最大并发连接数
    poolMin: 5,
    poolIncrement: 5,
    poolTimeout: 60
  });
}
// 初始化连接池（在应用启动时执行一次）
initDbBPool().catch(err => console.error('初始化数据库B连接池失败:', err));

第二步：分批处理账单列表 #

把1000条账单分成若干批次，每次只处理一批（比如20条），避免同时发起太多请求：

async function processBills(billsList) {
  const batchSize = 20; // 和连接池poolMax保持一致
  const processedResults = [];

  for (let i = 0; i < billsList.length; i += batchSize) {
    // 截取当前批次的账单
    const currentBatch = billsList.slice(i, i + batchSize);
    
    // 并行处理当前批次的所有账单
    const batchResults = await Promise.all(
      currentBatch.map(async (bill) => {
        let connection;
        try {
          // 从连接池获取连接
          connection = await oracledb.getConnection();
          
          const result = await connection.execute(
            'SELECT * FROM customers WHERE bill_id = :billId',
            [bill.billId]
          );
          
          // 把客户信息和账单合并
          return {
            ...bill,
            customer: result.rows.length > 0 ? result.rows[0] : null
          };
        } catch (err) {
          console.error(`处理账单${bill.billId}失败:`, err);
          // 即使失败也返回带错误信息的对象，避免中断整个流程
          return { ...bill, error: err.message };
        } finally {
          // 用完连接要还给连接池
          if (connection) {
            await connection.close();
          }
        }
      })
    );
    
    processedResults.push(...batchResults);
  }

  return processedResults;
}

// 使用示例
async function main() {
  // 从数据库A获取已发布账单
  const billsFromA = await getPublishedBills(targetDate);
  // 处理并关联客户信息
  const finalList = await processBills(billsFromA);
  console.log('处理完成:', finalList);
}

main().catch(err => console.error('主流程失败:', err));

3. 用Promise.allSettled做容错（仅辅助） #

如果只是想让所有请求都执行完毕，不管成功失败，可以用Promise.allSettled替代Promise.all，但这不能解决并发过载的问题，必须和上面的分批处理配合使用：

// 在批次处理中替换成allSettled
const batchResults = await Promise.allSettled(
  currentBatch.map(async (bill) => {
    // ...和之前一样的查询逻辑
  })
);

// 之后可以过滤成功的结果
const successResults = batchResults
  .filter(res => res.status === 'fulfilled')
  .map(res => res.value);

总结一下：优先尝试跨库JOIN，这是最省心高效的；如果不行，就用连接池+分批处理控制并发数，这样既能保证所有请求被处理，又不会触发数据库的限制。

内容的提问来源于stack exchange，提问作者J. Meyer