Node.js 进程管理

核心知识点

进程管理概述

进程管理是 Node.js 应用开发中的重要环节，特别是在处理计算密集型任务、提高系统吞吐量和实现高可用性时。Node.js 提供了多种进程管理机制，包括创建子进程、多进程集群和进程间通信等。

进程管理的主要目标：

• 充分利用多核 CPU 资源
• 提高应用的并发处理能力
• 实现任务的并行执行
• 提高应用的可靠性和容错性
• 实现负载均衡

进程类型

1. 主进程（Master Process）：

   • 负责管理和协调工作进程
   • 不处理具体的业务逻辑
   • 监控工作进程的状态

2. 工作进程（Worker Process）：

   • 处理具体的业务逻辑
   • 由主进程创建和管理
   • 多个工作进程可以并行执行任务

3. 子进程（Child Process）：

   • 通过 child_process 模块创建
   • 可以执行外部命令或 Node.js 脚本
   • 与父进程通过 IPC 通道通信

进程管理模块

• child_process：创建和管理子进程
• cluster：实现多进程集群，用于网络应用
• process：当前进程的信息和控制
• os：操作系统相关的实用工具，如获取 CPU 数量

实用案例分析

案例 1：使用 child_process 创建子进程

问题：需要执行外部命令或脚本

解决方案：使用 child_process 模块的不同方法创建子进程。

代码示例：

const { exec, spawn, fork, execFile } = require('child_process');

// 方法 1：exec - 执行命令并获取输出
function executeCommand() {
  exec('ls -la', (error, stdout, stderr) => {
    if (error) {
      console.error(`执行错误: ${error.message}`);
      return;
    }
    if (stderr) {
      console.error(`stderr: ${stderr}`);
      return;
    }
    console.log(`stdout: ${stdout}`);
  });
}

// 方法 2：spawn - 启动新进程，支持流式输出
function spawnProcess() {
  const child = spawn('ping', ['-c', '4', 'google.com']);
  
  child.stdout.on('data', (data) => {
    console.log(`stdout: ${data}`);
  });
  
  child.stderr.on('data', (data) => {
    console.error(`stderr: ${data}`);
  });
  
  child.on('close', (code) => {
    console.log(`子进程退出，退出码 ${code}`);
  });
}

// 方法 3：fork - 专门用于创建 Node.js 子进程
function forkProcess() {
  const child = fork('./child.js');
  
  // 发送消息给子进程
  child.send({ message: 'Hello from parent' });
  
  // 接收子进程的消息
  child.on('message', (message) => {
    console.log(`从子进程收到: ${message}`);
  });
  
  // 监听子进程退出
  child.on('exit', (code) => {
    console.log(`子进程退出，退出码 ${code}`);
  });
}

// 方法 4：execFile - 执行可执行文件
function executeFile() {
  execFile('node', ['--version'], (error, stdout, stderr) => {
    if (error) {
      console.error(`执行错误: ${error.message}`);
      return;
    }
    if (stderr) {
      console.error(`stderr: ${stderr}`);
      return;
    }
    console.log(`Node.js 版本: ${stdout}`);
  });
}

// 执行示例
console.log('=== 使用 exec 执行命令 ===');
executeCommand();

console.log('\n=== 使用 spawn 执行命令 ===');
spawnProcess();

console.log('\n=== 使用 fork 创建子进程 ===');
forkProcess();

console.log('\n=== 使用 execFile 执行文件 ===');
executeFile();

child.js

// 子进程代码

// 接收来自父进程的消息
process.on('message', (message) => {
  console.log(`从父进程收到: ${message}`);
  
  // 发送消息给父进程
  process.send('Hello from child');
  
  // 退出子进程
  setTimeout(() => {
    process.exit(0);
  }, 1000);
});

案例 2：使用 cluster 模块实现多进程集群

问题：需要充分利用多核 CPU 资源，提高网络应用的性能

解决方案：使用 cluster 模块创建多进程集群，实现负载均衡。

代码示例：

const cluster = require('cluster');
const http = require('http');
const os = require('os');
const numCPUs = 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} 已退出`);
    // 重启退出的工作进程
    console.log('重启工作进程...');
    cluster.fork();
  });
  
  // 监听工作进程在线
  cluster.on('online', (worker) => {
    console.log(`工作进程 ${worker.process.pid} 已在线`);
  });
  
  // 监听工作进程消息
  cluster.on('message', (worker, message, handle) => {
    console.log(`从工作进程 ${worker.process.pid} 收到消息: ${message}`);
  });
} else {
  // 工作进程创建 HTTP 服务器
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Hello World! 由工作进程 ${process.pid} 处理\n`);
    
    // 向主进程发送消息
    process.send(`处理了一个请求`);
  }).listen(8000);
  
  console.log(`工作进程 ${process.pid} 已启动，监听端口 8000`);
}

案例 3：进程间通信

问题：需要在不同进程之间传递数据和消息

解决方案：使用 IPC（Inter-Process Communication）通道进行进程间通信。

代码示例：

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

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // 创建工作进程
  const worker = cluster.fork();
  
  // 向工作进程发送消息
  worker.send({ type: 'task', data: '处理一些数据' });
  
  // 接收工作进程的消息
  worker.on('message', (message) => {
    console.log(`主进程收到:`, message);
    if (message.type === 'result') {
      console.log(`任务结果: ${message.data}`);
      // 可以在这里处理结果
    }
  });
  
  // 监听工作进程退出
  worker.on('exit', () => {
    console.log('工作进程已退出');
  });
} else {
  console.log(`工作进程 ${process.pid} 已启动`);
  
  // 接收主进程的消息
  process.on('message', (message) => {
    console.log(`工作进程收到:`, message);
    if (message.type === 'task') {
      // 处理任务
      console.log(`处理任务: ${message.data}`);
      
      // 模拟任务处理
      setTimeout(() => {
        // 向主进程发送结果
        process.send({ type: 'result', data: '任务处理完成' });
        
        // 退出工作进程
        process.exit(0);
      }, 2000);
    }
  });
}

案例 4：使用 child_process 执行外部命令

问题：需要在 Node.js 应用中执行外部命令，如系统工具或其他脚本

解决方案：使用 child_process 模块的 exec 或 spawn 方法执行外部命令。

代码示例：

const { exec, spawn } = require('child_process');

// 示例 1：执行系统命令并获取输出
function executeSystemCommand() {
  console.log('=== 执行系统命令 ===');
  
  exec('uname -a', (error, stdout, stderr) => {
    if (error) {
      console.error(`执行错误: ${error.message}`);
      return;
    }
    if (stderr) {
      console.error(`stderr: ${stderr}`);
      return;
    }
    console.log(`系统信息: ${stdout}`);
  });
}

// 示例 2：执行长时间运行的命令并实时获取输出
function executeLongRunningCommand() {
  console.log('\n=== 执行长时间运行的命令 ===');
  
  // 执行 ping 命令
  const pingProcess = spawn('ping', ['-c', '5', 'localhost']);
  
  // 实时获取标准输出
  pingProcess.stdout.on('data', (data) => {
    console.log(`ping 输出: ${data}`);
  });
  
  // 实时获取错误输出
  pingProcess.stderr.on('data', (data) => {
    console.error(`ping 错误: ${data}`);
  });
  
  // 监听命令执行完成
  pingProcess.on('close', (code) => {
    console.log(`ping 命令执行完成，退出码: ${code}`);
  });
}

// 示例 3：执行 Node.js 脚本
function executeNodeScript() {
  console.log('\n=== 执行 Node.js 脚本 ===');
  
  exec('node -e "console.log(\"Hello from Node.js script\")"', (error, stdout, stderr) => {
    if (error) {
      console.error(`执行错误: ${error.message}`);
      return;
    }
    if (stderr) {
      console.error(`stderr: ${stderr}`);
      return;
    }
    console.log(`脚本输出: ${stdout}`);
  });
}

// 执行示例
executeSystemCommand();
executeLongRunningCommand();
executeNodeScript();

案例 5：实现简单的任务调度器

问题：需要在后台执行定时任务或批量任务

解决方案：使用 child_process 模块创建子进程执行任务，并实现任务的调度和管理。

代码示例：

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

class TaskScheduler {
  constructor(maxWorkers = 2) {
    this.maxWorkers = maxWorkers;
    this.workers = [];
    this.taskQueue = [];
    this.runningTasks = 0;
  }
  
  // 添加任务
  addTask(taskData) {
    this.taskQueue.push(taskData);
    this.processQueue();
  }
  
  // 处理任务队列
  processQueue() {
    while (this.runningTasks < this.maxWorkers && this.taskQueue.length > 0) {
      const taskData = this.taskQueue.shift();
      this.executeTask(taskData);
    }
  }
  
  // 执行任务
  executeTask(taskData) {
    this.runningTasks++;
    
    const worker = fork(path.join(__dirname, 'taskWorker.js'));
    this.workers.push(worker);
    
    // 向工作进程发送任务
    worker.send({ taskData });
    
    // 接收工作进程的消息
    worker.on('message', (message) => {
      console.log('任务执行结果:', message);
      this.completeTask(worker);
    });
    
    // 监听工作进程错误
    worker.on('error', (error) => {
      console.error('工作进程错误:', error);
      this.completeTask(worker);
    });
    
    // 监听工作进程退出
    worker.on('exit', (code) => {
      console.log(`工作进程退出，退出码: ${code}`);
    });
  }
  
  // 完成任务
  completeTask(worker) {
    this.runningTasks--;
    // 从工作进程列表中移除
    this.workers = this.workers.filter(w => w !== worker);
    // 继续处理队列中的任务
    this.processQueue();
  }
  
  // 关闭所有工作进程
  shutdown() {
    this.workers.forEach(worker => {
      worker.kill();
    });
    console.log('所有工作进程已关闭');
  }
}

// 使用示例
const scheduler = new TaskScheduler(3); // 最多同时执行 3 个任务

// 添加任务
for (let i = 1; i <= 10; i++) {
  scheduler.addTask({ id: i, data: `任务 ${i}` });
}

// 监听进程退出
process.on('SIGINT', () => {
  scheduler.shutdown();
  process.exit(0);
});

taskWorker.js

// 任务工作进程

process.on('message', (message) => {
  const { taskData } = message;
  console.log(`工作进程 ${process.pid} 开始执行任务:`, taskData);
  
  // 模拟任务执行（异步操作）
  setTimeout(() => {
    const result = `任务 ${taskData.id} 执行完成`;
    console.log(`工作进程 ${process.pid} 完成任务:`, taskData.id);
    
    // 向父进程发送结果
    process.send({ taskId: taskData.id, result });
    
    // 退出工作进程
    process.exit(0);
  }, Math.random() * 2000 + 1000); // 随机执行时间 1-3 秒
});

进程管理最佳实践

1. 资源管理

• 合理设置工作进程数量：

  • 通常设置为 CPU 核心数量或略多
  • 避免过多的工作进程导致资源竞争

• 监控系统资源使用：

  • 监控 CPU、内存、磁盘和网络使用情况
  • 根据资源使用情况动态调整工作进程数量

• 避免内存泄漏：

  • 定期检查和清理工作进程的内存使用
  • 对于长时间运行的应用，考虑定期重启工作进程

2. 错误处理和容错

• 实现工作进程自动重启：

  • 当工作进程崩溃时，自动重启
  • 避免因单个工作进程故障导致整个应用不可用

• 实现优雅关闭：

  • 当需要关闭应用时，先处理完当前请求
  • 向客户端发送适当的关闭通知

• 错误隔离：

  • 确保单个工作进程的错误不会影响其他工作进程
  • 实现错误捕获和日志记录

3. 负载均衡

• 使用轮询或其他负载均衡策略：

  • cluster 模块默认使用轮询策略分发请求
  • 可以根据实际情况选择其他负载均衡策略

• 实现请求队列：

  • 当所有工作进程都繁忙时，将请求加入队列
  • 避免系统过载

• 监控工作进程负载：

  • 定期检查工作进程的负载情况
  • 根据负载情况调整工作进程数量

4. 进程间通信优化

• 减少进程间通信的频率：

  • 避免频繁的消息传递
  • 批量处理消息

• 使用高效的序列化格式：

  • 对于大型数据，考虑使用更高效的序列化格式
  • 避免传递不必要的数据

• 实现消息确认机制：

  • 确保重要消息的可靠传递
  • 处理消息传递失败的情况

5. 部署和管理

• 使用进程管理工具：

  • PM2：生产级进程管理器，提供负载均衡、自动重启等功能
  • Forever：简单的进程管理工具，确保应用持续运行

• 实现监控和告警：

  • 监控工作进程的状态和性能
  • 当出现异常时，及时发送告警

• 配置管理：

  • 使用环境变量或配置文件管理进程配置
  • 实现配置的热更新

常见问题与解决方案

问题 1：工作进程数量设置不合理

症状：

• CPU 使用率过高或过低
• 内存使用过高
• 应用响应速度慢

解决方案：

• 根据 CPU 核心数量设置工作进程数量
• 进行性能测试，找到最佳的工作进程数量
• 考虑应用的内存使用情况，避免内存不足

问题 2：进程间通信开销过大

症状：

• 应用性能下降
• 消息传递延迟增加
• 系统负载过高

解决方案：

• 减少进程间通信的频率
• 优化消息结构，减少数据量
• 考虑使用共享内存或其他高效的通信方式

问题 3：工作进程崩溃导致服务不可用

症状：

• 部分请求失败
• 应用响应不及时
• 错误日志中出现大量工作进程崩溃信息

解决方案：

• 实现工作进程自动重启机制
• 分析工作进程崩溃的原因，修复根本问题
• 增加错误处理和容错机制

问题 4：负载均衡不均

症状：

• 部分工作进程负载过高
• 部分工作进程空闲
• 系统整体性能下降

解决方案：

• 检查负载均衡策略是否合适
• 实现动态负载均衡
• 监控工作进程的负载情况，及时调整

问题 5：内存泄漏

症状：

• 内存使用持续增长
• 工作进程变得越来越慢
• 最终导致工作进程崩溃

解决方案：

• 使用内存分析工具定位内存泄漏
• 修复代码中的内存泄漏问题
• 实现定期重启工作进程的机制

进程管理工具

1. PM2

PM2（Process Manager 2）是一个生产级的 Node.js 进程管理器，提供了丰富的功能，如负载均衡、自动重启、监控等。

安装和使用

# 安装 PM2
npm install -g pm2

# 启动应用
pm start app.js

# 查看应用状态
pm status

# 监控应用
pm monit

# 重启应用
pm restart app

# 停止应用
pm stop app

# 查看应用日志
pm logs

# 生成启动脚本
pm startup

配置文件

ecosystem.config.js

module.exports = {
  apps: [
    {
      name: 'myapp',
      script: 'app.js',
      instances: 'max', // 使用最大数量的实例
      exec_mode: 'cluster', // 集群模式
      env: {
        NODE_ENV: 'development'
      },
      env_production: {
        NODE_ENV: 'production'
      },
      log_file: 'logs/app.log',
      out_file: 'logs/out.log',
      error_file: 'logs/error.log'
    }
  ]
};

2. Forever

Forever 是一个简单的进程管理工具，确保应用持续运行，当应用崩溃时自动重启。

安装和使用

# 安装 Forever
npm install -g forever

# 启动应用
forever start app.js

# 查看应用状态
forever list

# 停止应用
forever stop app.js

# 重启应用
forever restart app.js

# 查看应用日志
forever logs

总结

进程管理是 Node.js 应用开发中的重要环节，特别是在构建高性能、高可靠性的应用时。通过本文的学习，你应该：

1. 理解 Node.js 进程管理的核心概念和目标
2. 掌握 child_process 和 cluster 模块的使用方法
3. 学会实现进程间通信
4. 构建多进程应用，充分利用多核 CPU 资源
5. 了解进程管理的最佳实践和常见问题解决方案
6. 学会使用 PM2 等进程管理工具

进程管理可以显著提高应用的性能和可靠性，特别是在处理并发请求、计算密集型任务和实现高可用性时。通过合理的进程管理策略，可以充分发挥系统的潜力，构建更加高效、稳定的 Node.js 应用。

记住，进程管理不是一成不变的，需要根据应用的具体情况和需求进行调整和优化。通过不断地学习和实践，你将能够构建出更加优秀的 Node.js 应用。