异步IO性能瓶颈分析

Node.js 异步 IO 通过 libuv 线程池处理，瓶颈常出现在线程池阻塞、IO 调度、异步操作堆积。

libuv IO 模型

线程池架构

+------------------+
|  Node.js Main    |  ← 事件循环主线程
+------------------+
|     libuv        |  ← IO 调度层
+------------------+
|  Thread Pool     |  ← 4个默认工作线程
|  [T1][T2][T3][T4]|
+------------------+
|  System IO       |  ← 文件/网络/信号
+------------------+

IO 类型与处理方式

默认线程池大小

// 默认4个线程
console.log(process.env.UV_THREADPOOL_SIZE);  // undefined

// 查看当前设置
const uv = require('uv');
// Node.js 无直接 API，通过环境变量设置

// 调整线程池大小（启动前设置）
process.env.UV_THREADPOOL_SIZE = 128;  // 最多128

线程池阻塞诊断

监控线程池状态

const { performance, PerformanceObserver } = require('perf_hooks');

// 监控异步操作耗时
const obs = new PerformanceObserver((list) => {
  const entries = list.getEntries();
  entries.forEach(entry => {
    console.log(`${entry.name}: ${entry.duration.toFixed(2)}ms`);
  });
});
obs.observe({ entryTypes: ['node'] });

// 标记异步操作
performance.mark('fs-start');
fs.readFile('large-file.txt', (err, data) => {
  performance.mark('fs-end');
  performance.measure('fs-read', 'fs-start', 'fs-end');
});

识别阻塞特征

症状：
1. CPU 使用率低但吞吐量下降
2. 并发请求响应时间线性增长
3. 文件操作队列堆积
4. 事件循环 tick 延长

使用 clinic.js bubbleprof

# 安装
npm install -g clinic

# 运行分析
clinic bubbleprof -- node app.js

# 生成可视化报告
# 显示异步操作阻塞关系图

文件 IO 瓶颈

问题场景

// 瓶颈：同步文件操作阻塞主线程
const data = fs.readFileSync('large.json');  // 阻塞！
processData(data);

// 瓶颈：大量并发文件读取阻塞线程池
app.get('/file/:name', (req, res) => {
  fs.readFile(req.params.name, (err, data) => {
    // 4线程池，5个并发请求就排队等待
    res.send(data);
  });
});

诊断代码

const fs = require('fs');
const { performance } = require('perf_hooks');

// 监控文件操作耗时
function monitoredRead(path) {
  const start = performance.now();
  return new Promise((resolve, reject) => {
    fs.readFile(path, (err, data) => {
      const elapsed = performance.now() - start;
      console.log(`fs.readFile(${path}): ${elapsed.toFixed(2)}ms`);
      if (err) reject(err);
      else resolve(data);
    });
  });
}

// 批量测试线程池饱和
async function testThreadPool() {
  const tasks = [];
  for (let i = 0; i < 10; i++) {
    tasks.push(monitoredRead('large-file.bin'));
  }
  const results = await Promise.all(tasks);
  // 分析耗时差异，判断排队情况
}

优化策略

// 1. 使用流式处理
const readStream = fs.createReadStream('large-file.bin', {
  highWaterMark: 64 * 1024  // 64KB 缓冲区
});

// 2. 增大线程池
process.env.UV_THREADPOOL_SIZE = 32;

// 3. 拆分大文件操作
async function chunkedRead(path, chunkSize = 1024 * 1024) {
  const stats = await fs.promises.stat(path);
  const chunks = [];
  for (let offset = 0; offset < stats.size; offset += chunkSize) {
    const fd = await fs.promises.open(path, 'r');
    const buf = Buffer.alloc(chunkSize);
    await fd.read(buf, 0, chunkSize, offset);
    chunks.push(buf);
    await fd.close();
  }
  return Buffer.concat(chunks);
}

// 4. 使用 worker_threads 替代
const { Worker } = require('worker_threads');
function readFileInWorker(path) {
  return new Promise((resolve, reject) => {
    const worker = new Worker(`
      const fs = require('fs');
      fs.readFile('${path}', (err, data) => {
        if (err) reject(err);
        else resolve(data);
      });
    `, { eval: true });
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

网络 IO 瓶颈

TCP 连接瓶颈

// 问题：连接池耗尽
const http = require('http');

// 默认每个域名5个连接
// 高并发时连接等待
for (let i = 0; i < 100; i++) {
  http.get('http://slow-api.com/data', (res) => {
    // 排队等待连接
  });
}

诊断连接状态

const http = require('http');

// 设置连接池大小
http.globalAgent.maxSockets = 50;  // 每个域名最大连接数
http.globalAgent.maxFreeSockets = 10;  // 保持空闲连接数

// 查看连接池状态
console.log('sockets:', Object.keys(http.globalAgent.sockets));
console.log('requests:', Object.keys(http.globalAgent.requests));

Keep-Alive 优化

const http = require('http');

// 启用 Keep-Alive
const agent = new http.Agent({
  keepAlive: true,
  keepAliveMsecs: 30000,  // 30秒
  maxSockets: 50,
  maxFreeSockets: 10,
  timeout: 30000
});

// 使用自定义 agent
const options = {
  hostname: 'api.example.com',
  agent: agent
};

http.get(options, (res) => { });

// 查看复用情况
agent.on('free', (socket, options) => {
  console.log('Socket freed, can reuse');
});

DNS 解析瓶颈

// DNS 解析在线程池，可能阻塞
const dns = require('dns');

// 缓存 DNS 结果
const dnsCache = new Map();

async function cachedLookup(hostname) {
  if (dnsCache.has(hostname)) {
    return dnsCache.get(hostname);
  }
  const result = await dns.promises.lookup(hostname);
  dnsCache.set(hostname, result);
  // 设置过期
  setTimeout(() => dnsCache.delete(hostname), 300000);
  return result;
}

// 使用系统缓存
// /etc/nsswitch.conf 或 hosts 文件

异步队列堆积

检测队列堆积

// 监控 Promise 队列
let pendingPromises = 0;

function trackPromise(promise) {
  pendingPromises++;
  return promise.finally(() => {
    pendingPromises--;
  });
}

// 定时检查
setInterval(() => {
  if (pendingPromises > 100) {
    console.warn(`Warning: ${pendingPromises} pending promises`);
  }
}, 1000);

监控事件循环延迟

const { monitorEventLoopDelay } = require('perf_hooks');

const h = monitorEventLoopDelay({
  resolution: 10  // 10ms 精度
});
h.enable();

setInterval(() => {
  console.log({
    mean: h.mean.toFixed(2) + 'ms',
    max: h.max.toFixed(2) + 'ms',
    min: h.min.toFixed(2) + 'ms',
    percentiles: {
      p50: h.percentile(50).toFixed(2),
      p99: h.percentile(99).toFixed(2)
    }
  });
}, 5000);

队列限流

// 实现异步队列限流
class AsyncQueue {
  constructor(concurrency = 4) {
    this.concurrency = concurrency;
    this.running = 0;
    this.queue = [];
  }

  async run(task) {
    if (this.running >= this.concurrency) {
      await new Promise(resolve => this.queue.push(resolve));
    }
    this.running++;
    try {
      return await task();
    } finally {
      this.running--;
      if (this.queue.length > 0) {
        this.queue.shift()();
      }
    }
  }

  get pending() {
    return this.queue.length;
  }
}

// 使用
const queue = new AsyncQueue(10);
for (let i = 0; i < 100; i++) {
  queue.run(() => fetchData(i));
}

IO 性能测试

压测工具

# 使用 autocannon
npm install -g autocannon

autocannon -c 100 -d 30 http://localhost:3000/api

# 结果分析
# - latency p99 < 100ms 为佳
# - throughput 稳定无下降

自定义压测

const autocannon = require('autocannon');

async function bench() {
  const result = await autocannon({
    url: 'http://localhost:3000',
    connections: 100,
    duration: 30,
    requests: [
      { method: 'GET', path: '/api/data' }
    ]
  });

  console.log({
    latency: {
      mean: result.latency.mean,
      p99: result.latency.p99
    },
    throughput: result.throughput.average,
    errors: result.errors
  });
}

IO 瓶颈定位流程

1. 监控事件循环延迟
   ↓ 延迟 > 50ms
2. 检查线程池利用率
   ↓ 线程池饱和
3. 分析 IO 操作耗时
   ↓ 找到慢操作
4. 定位阻塞源头
   ↓ 文件/网络/DNS
5. 应用优化策略

注意：线程池增大不能无限提升性能，CPU 核心数是上限，通常设置为 4×CPU核心数。

要点总结

• 文件 IO 和 DNS 解析使用线程池，4线程默认配置易饱和
• 监控事件循环延迟判断 IO 阻塞程度
• 使用流式处理、增大线程池、Worker Threads 优化文件 IO
• 配置 Keep-Alive 和连接池优化网络 IO
• 实现异步队列限流防止请求堆积