多核CPU利用

多核CPU的基本概念

现代计算机普遍采用多核CPU架构，单个物理CPU包含多个独立处理核心。Node.js作为单线程运行时，默认情况下无法充分利用多核优势。理解CPU核心如何工作对性能优化至关重要。每个核心可以并行执行指令，拥有独立的L1/L2缓存，共享L3缓存和内存控制器。

const os = require('os');
console.log(`CPU核心数: ${os.cpus().length}`);

典型服务器可能有32或64个核心，但Node.js单进程只能使用其中一个。当处理CPU密集型任务时，这会造成严重的资源浪费。例如图像处理、视频转码或复杂数学计算时，单线程性能瓶颈会非常明显。

Node.js的线程模型限制

Node.js基于事件循环机制，采用单线程处理JavaScript代码。虽然底层I/O操作通过线程池实现异步，但主线程仍然是单线程的。这种设计带来了高效的I/O性能，但也导致CPU密集型任务处理能力受限。

// 模拟CPU密集型任务
function calculatePrimes(max) {
  const primes = [];
  for (let i = 2; i <= max; i++) {
    let isPrime = true;
    for (let j = 2; j < i; j++) {
      if (i % j === 0) {
        isPrime = false;
        break;
      }
    }
    if (isPrime) primes.push(i);
  }
  return primes;
}

// 这会阻塞事件循环
app.get('/primes', (req, res) => {
  const primes = calculatePrimes(100000);
  res.json(primes);
});

Cluster模块的核心原理

Node.js内置的cluster模块允许创建共享同一端口的多个进程。主进程（master）负责管理工作进程（worker），每个worker都是独立的V8实例。

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // 衍生工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
  });
} else {
  // 工作进程可以共享任何TCP连接
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('你好世界\n');
  }).listen(8000);

  console.log(`工作进程 ${process.pid} 已启动`);
}

Worker Threads的深入应用

worker_threads模块提供了更轻量级的线程方案，适合CPU密集型但需要共享内存的场景。与cluster不同，worker threads共享同一进程内存空间。

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

if (isMainThread) {
  module.exports = function parseJSAsync(script) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, {
        workerData: script
      });
      worker.on('message', resolve);
      worker.on('error', reject);
      worker.on('exit', (code) => {
        if (code !== 0)
          reject(new Error(`Worker stopped with exit code ${code}`));
      });
    });
  };
} else {
  const { parse } = require('some-parse-library');
  const script = workerData;
  parentPort.postMessage(parse(script));
}

进程间通信的优化策略

多进程架构中，IPC（进程间通信）是性能关键点。常见方法包括：

1. Node.js内置的process.send()
2. 共享内存（SharedArrayBuffer）
3. 消息队列（如Redis）
4. Unix域套接字

// 使用SharedArrayBuffer进行高效通信
const { Worker } = require('worker_threads');
const sharedBuffer = new SharedArrayBuffer(4);
const array = new Uint32Array(sharedBuffer);

const worker = new Worker(`
  const { parentPort, workerData } = require('worker_threads');
  const array = new Uint32Array(workerData);
  Atomics.add(array, 0, 1);
  parentPort.postMessage('done');
`, { eval: true, workerData: sharedBuffer });

worker.on('message', () => {
  console.log('Buffer value:', array[0]);  // 输出: Buffer value: 1
});

负载均衡的实践方案

有效分配请求到不同工作进程是核心挑战。常见策略包括：

• 轮询（Round-robin）
• 最少连接数
• 加权分配
• 基于响应时间的动态调整

// 自定义负载均衡逻辑
cluster.on('fork', (worker) => {
  worker.on('message', (msg) => {
    if (msg.type === 'latency') {
      // 根据延迟动态调整权重
      updateWorkerWeight(worker.id, msg.value);
    }
  });
});

function updateWorkerWeight(workerId, latency) {
  // 实现权重更新逻辑
  // 低延迟worker获得更高权重
}

内存管理的注意事项

多进程架构会带来内存开销，每个worker都有独立的V8堆内存。需要特别注意：

• 避免worker内存泄漏
• 合理设置worker数量
• 监控内存使用情况

// 内存监控示例
setInterval(() => {
  const memoryUsage = process.memoryUsage();
  console.log({
    rss: memoryUsage.rss / 1024 / 1024 + 'MB',
    heapTotal: memoryUsage.heapTotal / 1024 / 1024 + 'MB',
    heapUsed: memoryUsage.heapUsed / 1024 / 1024 + 'MB',
    external: memoryUsage.external / 1024 / 1024 + 'MB'
  });
}, 5000);

实际应用场景分析

视频处理服务是典型的多核利用案例。转码过程可以分割成多个片段并行处理：

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

function processVideoSegment(segment) {
  return new Promise((resolve) => {
    const worker = new Worker('./video-worker.js', { 
      workerData: segment 
    });
    worker.on('message', resolve);
  });
}

async function processVideo(video) {
  const segments = splitVideo(video);
  const results = await Promise.all(
    segments.map(segment => processVideoSegment(segment))
  );
  return mergeVideoSegments(results);
}

性能监控与调试技巧

完善的监控系统对多核应用至关重要。关键指标包括：

• 各worker CPU使用率
• 事件循环延迟
• 内存占用
• 请求处理时间

// 使用perf_hooks监控性能
const { performance, PerformanceObserver } = require('perf_hooks');

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

performance.mark('A');
// 执行一些操作
performance.mark('B');
performance.measure('A to B', 'A', 'B');

错误处理与进程恢复

多进程环境需要健壮的错误处理机制：

1. 未捕获异常处理
2. 进程崩溃自动重启
3. 优雅退出机制
4. 状态恢复策略

// 进程错误处理示例
cluster.on('exit', (worker, code, signal) => {
  if (code !== 0 && !worker.exitedAfterDisconnect) {
    console.log(`Worker ${worker.id} crashed. Starting a new worker...`);
    const newWorker = cluster.fork();
    transferConnections(worker, newWorker);
  }
});

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
  // 执行清理工作后退出
  cleanup().then(() => process.exit(1));
});

容器化环境下的特殊考量

在Kubernetes等容器编排系统中，需要考虑：

• CPU资源限制
• 健康检查配置
• 水平扩展策略
• 亲和性调度

// 根据容器资源限制动态调整worker数量
function getOptimalWorkerCount() {
  const availableCPUs = process.env.NODE_ENV === 'production' 
    ? Math.min(
        require('os').cpus().length,
        parseInt(process.env.CPU_LIMIT || '1')
      )
    : 1;
  
  return Math.max(1, availableCPUs - 1); // 保留一个核心给主进程
}