Node.js使用pg库批量查询PostgreSQL无并行问题咨询

首先明确：这不是PostgreSQL的正常行为，问题出在你的Node.js代码对数据库连接和并发的处理方式上，而非数据库本身。PostgreSQL是支持多客户端并行查询的，下面具体分析原因和解决方案：

为什么会出现排队？ #

1. 连接池资源被耗尽：pg的Pool默认最大连接数是10，你的代码在同步for循环里一次性发起20000次pool.connect()调用，这些请求会立刻占满整个连接池，后续新的客户端请求只能等待连接被释放才能获取资源。
2. 同步循环+回调式写法的问题：你用同步for循环批量触发异步查询，加上回调式的连接/查询写法，会导致事件循环被大量待处理的请求占据，无法高效调度其他客户端的请求，看起来就像完全排队。

解决方法 #

1. 合理配置连接池 #

首先根据你的服务器和数据库资源，调整连接池的最大连接数（不要超过PostgreSQL的默认最大连接数100，否则数据库会拒绝新连接）：

const pool = new Pool({
  max: 20, // 可根据实际情况调整，比如20-50之间
  // 补充你的数据库连接配置：host, user, password, database等
});

2. 改用Async/Await+并发控制 #

放弃同步循环和回调写法，用async/await让代码更易维护，同时限制并发查询的数量，避免一下子占满连接池：

const express = require('express');
const app = express();
const { Pool } = require("pg");

const pool = new Pool({
  max: 20
});

// 改写benchmark为async函数
async function benchmark() {
  let client;
  try {
    client = await pool.connect();
    const res = await client.query("SELECT * from member where m_id = $1", [1]);
    console.log(res.rows[0]);
  } catch (err) {
    console.error(err.stack);
  } finally {
    if (client) {
      client.release(); // 确保连接被释放回池，避免资源泄漏
    }
  }
}

// 控制并发数，比如同时处理50个查询
const CONCURRENCY_LIMIT = 50;

app.get('/', async function(req, res) {
  try {
    const promiseBatch = [];
    for (let i = 0; i < 20000; i++) {
      promiseBatch.push(benchmark());
      // 每攒够一批就等待执行完成，再继续下一批
      if (i % CONCURRENCY_LIMIT === CONCURRENCY_LIMIT - 1) {
        await Promise.all(promiseBatch);
        promiseBatch.length = 0;
      }
    }
    // 处理剩余未执行的查询
    if (promiseBatch.length > 0) {
      await Promise.all(promiseBatch);
    }
    res.status(200).send('Benchmark completed successfully');
  } catch (err) {
    console.error('Benchmark failed:', err);
    res.status(500).send('Benchmark failed');
  }
});

app.listen(3000, () => console.log('Server running on port 3000'));

3. 从根源优化查询（最重要） #

如果你的20000次查询都是针对同一个m_id=1，那完全没必要发起这么多次请求——一次查询就能拿到结果，重复使用即可：

app.get('/', async function(req, res) {
  try {
    const client = await pool.connect();
    const dbRes = await client.query("SELECT * from member where m_id = $1", [1]);
    const result = dbRes.rows[0];
    client.release();
    // 直接重复使用查询结果，不用循环发起20000次请求
    for (let i = 0; i < 20000; i++) {
      console.log(result);
    }
    res.send('Optimized benchmark completed');
  } catch (err) {
    console.error(err.stack);
    res.status(500).send('Error occurred');
  }
});

如果是针对不同的m_id，可以用IN语句批量查询，把多个m_id放到一个查询里，大幅减少数据库请求次数：

// 示例：分批查询不同的m_id，每次查1000个
const batchSize = 1000;
app.get('/', async function(req, res) {
  try {
    const client = await pool.connect();
    for (let i = 0; i < 20000; i += batchSize) {
      // 生成当前批次的id数组（根据你的实际需求调整）
      const currentIds = [...Array(batchSize)].map((_, idx) => i + idx + 1);
      // 生成对应的占位符
      const placeholders = currentIds.map((_, idx) => `$${idx+1}`).join(',');
      const dbRes = await client.query(
        `SELECT * from member where m_id IN (${placeholders})`,
        currentIds
      );
      // 处理当前批次的查询结果
      console.log(`Batch ${i/batchSize +1} result count:`, dbRes.rows.length);
    }
    client.release();
    res.send('Batch query completed');
  } catch (err) {
    console.error(err.stack);
    res.status(500).send('Error occurred');
  }
});

总结 #

PostgreSQL本身是支持多客户端并行处理的，你的排队问题是客户端代码的连接管理和并发控制不当导致的。通过调整连接池配置、改用异步并发控制写法，再加上查询本身的优化，就能避免单用户占用全部资源，让多个客户端的请求可以并行处理。

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