异步性能优化技巧

在Node.js中，异步性能优化是提升应用吞吐量和响应速度的关键。合理利用事件循环、避免阻塞操作、优化I/O处理等方式能显著改善性能表现。

事件循环与任务调度

Node.js的事件循环是异步编程的核心。理解不同阶段的优先级对优化至关重要：

// 微任务（nextTick和Promise）优先于宏任务（setTimeout等）
process.nextTick(() => console.log('nextTick 1'));
Promise.resolve().then(() => console.log('Promise 1'));
setTimeout(() => console.log('timeout 1'), 0);

// 输出顺序：
// nextTick 1
// Promise 1
// timeout 1

关键优化点：

1. 耗时同步操作拆分为异步任务
2. 合理使用setImmediate替代setTimeout(fn, 0)
3. 避免在nextTick中执行耗时操作

异步流程控制优化

Promise组合技巧

// 错误示范：顺序执行的Promise
const slowOperation = async () => {
  const res1 = await fetch('/api1');
  const res2 = await fetch('/api2');
  return [res1, res2];
};

// 优化版本：并行执行
const fastOperation = async () => {
  const [res1, res2] = await Promise.all([
    fetch('/api1'),
    fetch('/api2')
  ]);
  return [res1, res2];
};

流式处理大数据

const fs = require('fs');
const zlib = require('zlib');

// 传统方式（内存消耗大）
fs.readFile('large.log', (err, data) => {
  zlib.gzip(data, (err, compressed) => {
    fs.writeFile('large.log.gz', compressed);
  });
});

// 流式优化
fs.createReadStream('large.log')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('large.log.gz'));

集群与工作线程

Cluster模块基础用法

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const cpuCount = os.cpus().length;
  for (let i = 0; i < cpuCount; i++) {
    cluster.fork();
  }
} else {
  require('./app'); // 启动应用
}

Worker Threads实战

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

if (isMainThread) {
  // 主线程
  const worker = new Worker(`
    const { parentPort } = require('worker_threads');
    parentPort.on('message', (msg) => {
      // CPU密集型计算
      const result = heavyComputation(msg);
      parentPort.postMessage(result);
    });
  `, { eval: true });
  
  worker.on('message', result => {
    console.log('计算结果:', result);
  });
  
  worker.postMessage(1000000);
}

内存管理策略

对象池模式

class ObjectPool {
  constructor(createFn) {
    this.createFn = createFn;
    this.pool = [];
  }

  acquire() {
    return this.pool.pop() || this.createFn();
  }

  release(obj) {
    this.pool.push(obj);
  }
}

// 使用示例
const dbConnectionPool = new ObjectPool(() => createDBConnection());
const conn = dbConnectionPool.acquire();
// 使用后归还
dbConnectionPool.release(conn);

Buffer复用技巧

const bufferPool = (function() {
  const pools = [];
  return {
    get(size) {
      if (!pools[size]) pools[size] = [];
      return pools[size].pop() || Buffer.alloc(size);
    },
    put(buffer) {
      if (!pools[buffer.length]) pools[buffer.length] = [];
      pools[buffer.length].push(buffer);
    }
  };
})();

// 使用示例
const buf = bufferPool.get(1024);
// 使用后归还
bufferPool.put(buf);

高级异步模式

异步优先级队列

class PriorityQueue {
  constructor(concurrency = 1) {
    this.queue = [];
    this.activeCount = 0;
    this.concurrency = concurrency;
  }

  add(task, priority = 0) {
    return new Promise((resolve, reject) => {
      const item = { task, priority, resolve, reject };
      let inserted = false;
      for (let i = 0; i < this.queue.length; i++) {
        if (priority > this.queue[i].priority) {
          this.queue.splice(i, 0, item);
          inserted = true;
          break;
        }
      }
      if (!inserted) this.queue.push(item);
      this._next();
    });
  }

  _next() {
    if (this.activeCount >= this.concurrency || !this.queue.length) return;
    this.activeCount++;
    const { task, resolve, reject } = this.queue.shift();
    Promise.resolve(task())
      .then(resolve, reject)
      .finally(() => {
        this.activeCount--;
        this._next();
      });
  }
}

// 使用示例
const queue = new PriorityQueue(2);
queue.add(() => fetch('/low'), 1);
queue.add(() => fetch('/high'), 3);

性能监控与调优

事件循环延迟检测

function monitorEventLoop() {
  const interval = 1000;
  let last = process.hrtime.bigint();
  
  const timer = setInterval(() => {
    const start = process.hrtime.bigint();
    const delay = Number(start - last - BigInt(interval * 1e6)) / 1e6;
    
    if (delay > 10) {
      console.warn(`事件循环延迟: ${delay.toFixed(2)}ms`);
    }
    
    last = start;
  }, interval);

  return () => clearInterval(timer);
}

// 启动监控
const stopMonitoring = monitorEventLoop();

Async_hooks性能分析

const async_hooks = require('async_hooks');
const fs = require('fs');

// 创建跟踪器
const hook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    fs.writeSync(1, `Init: ${type}(${asyncId})\n`);
  },
  destroy(asyncId) {
    fs.writeSync(1, `Destroy: ${asyncId}\n`);
  }
});

// 启用钩子
hook.enable();

// 示例异步操作
setTimeout(() => {
  console.log('Async operation completed');
}, 100);