进程与线程概念

进程与线程的基本概念

进程是操作系统资源分配的基本单位，每个进程拥有独立的内存空间和系统资源。线程则是进程内的执行单元，一个进程可以包含多个线程，这些线程共享进程的资源。操作系统通过进程隔离保证程序运行的稳定性，而线程则提供了更轻量级的并发执行能力。

在Node.js环境中，虽然JavaScript本身是单线程的，但通过事件循环和异步I/O机制实现了高效的并发处理。Node.js底层使用libuv库处理异步操作，内部实际上维护了一个线程池用于执行文件I/O等阻塞操作。

Node.js中的进程模型

Node.js采用单进程单线程模型，但可以通过child_process模块创建子进程。主进程和子进程之间通过IPC（进程间通信）进行数据交换。这种设计使得Node.js既能保持轻量级特性，又能利用多核CPU的优势。

const { fork } = require('child_process');

// 创建子进程
const child = fork('child.js');

// 父进程发送消息
child.send({ hello: 'world' });

// 父进程接收消息
child.on('message', (msg) => {
  console.log('Message from child:', msg);
});

事件循环与线程池

Node.js的事件循环机制是其高并发的核心。事件循环运行在主线程上，负责处理非阻塞I/O操作和定时器。当遇到文件操作、DNS查询等可能阻塞的操作时，Node.js会将这些任务交给libuv的线程池处理。

const fs = require('fs');

// 异步文件读取会使用线程池
fs.readFile('/path/to/file', (err, data) => {
  if (err) throw err;
  console.log(data.toString());
});

// 同步操作会阻塞事件循环
const data = fs.readFileSync('/path/to/file');

工作线程(Worker Threads)

Node.js 10.x引入了worker_threads模块，允许创建真正的多线程应用。与子进程不同，工作线程共享相同的内存空间，但每个线程有自己的V8实例和事件循环。

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

if (isMainThread) {
  // 主线程代码
  const worker = new Worker(__filename);
  worker.on('message', (msg) => {
    console.log('Worker message:', msg);
  });
  worker.postMessage('Hello worker');
} else {
  // 工作线程代码
  parentPort.on('message', (msg) => {
    console.log('Main thread message:', msg);
    parentPort.postMessage('Hello main');
  });
}

进程与线程的性能考量

在Node.js中选择使用进程还是线程需要考虑多个因素：

• 进程隔离性好但创建成本高
• 线程共享内存但需要处理竞态条件
• CPU密集型任务适合使用工作线程
• I/O密集型任务通常事件循环就能很好处理

// 使用Promise.all并行处理多个异步任务
const fetch = require('node-fetch');

async function fetchMultiple(urls) {
  const promises = urls.map(url => fetch(url));
  const results = await Promise.all(promises);
  return Promise.all(results.map(res => res.json()));
}

进程间通信机制

Node.js提供了多种进程间通信方式：

• child_process模块的IPC通信
• cluster模块的进程间消息传递
• 共享内存（通过SharedArrayBuffer）
• 第三方消息队列如Redis、RabbitMQ

// 使用cluster模块创建多个工作进程
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker ' + process.pid);
  }).listen(8000);
}

错误处理与进程管理

在多进程/多线程环境中，错误处理尤为重要。未捕获的异常可能导致整个进程崩溃。Node.js提供了domain模块和process.on('uncaughtException')等机制来处理异常。

process.on('uncaughtException', (err) => {
  console.error('Uncaught exception:', err);
  // 执行必要的清理工作
  process.exit(1); // 退出进程
});

// 工作线程中的错误处理
const worker = new Worker('...');
worker.on('error', (err) => {
  console.error('Worker error:', err);
});

实际应用场景分析

不同类型的应用适合不同的并发模型：

• Web服务器：通常使用cluster模块创建多个进程
• 数据处理：适合使用worker_threads进行并行计算
• 微服务架构：每个服务可以运行在独立进程中
• 实时应用：结合事件循环和WebSocket实现高并发

// 使用worker_threads处理CPU密集型任务
const { Worker } = require('worker_threads');

function runService(workerData) {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./service.js', { workerData });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`));
    });
  });
}