JS Node.js `Cluster` 模块：多核 CPU 利用与负载均衡

各位观众老爷，大家好！我是你们的老朋友，一个在代码堆里摸爬滚打多年的老码农。今天咱们不聊风花雪月，来点硬核的——Node.js 的 cluster 模块，教你如何榨干 CPU 的最后一滴性能，让你的服务器跑得飞起！

开场白：单线程的无奈与多核的诱惑

Node.js 以其单线程、非阻塞 I/O 的特性著称，这使得它在处理高并发 I/O 密集型任务时表现出色。想象一下，你是个餐厅服务员（Node.js），一次只能服务一个客人（请求），但你动作很快，可以同时处理很多客人的点单、上菜、结账等操作，所以效率很高。

但是，如果你的餐厅里来了个大胃王（CPU 密集型任务），比如需要你算清所有客人的消费总额（复杂计算），你一个人就算得头昏脑胀，其他客人只能干等着。这就是 Node.js 单线程的局限性：当遇到 CPU 密集型任务时，整个进程会被阻塞，影响其他请求的处理。

这时候，你就需要更多服务员（CPU 核心）。现代服务器通常配备多核 CPU，但 Node.js 默认情况下只能利用一个核心。这就好比你开了一家拥有多个厨房的豪华餐厅，但只有一个厨师在忙活，其他的厨房都闲置着，这简直是暴殄天物啊！

cluster 模块就是来解决这个问题的，它允许你创建多个 Node.js 进程，每个进程运行在不同的 CPU 核心上，从而实现真正的并行处理，充分利用多核 CPU 的性能。

cluster 模块：化身多线程管理大师

cluster 模块的核心思想是创建一个主进程（Master Process），然后由主进程 fork 出多个工作进程（Worker Processes）。主进程负责管理工作进程，并根据需要创建新的工作进程。工作进程则负责处理实际的请求。

我们可以把主进程想象成餐厅经理，负责调度和管理；工作进程则相当于具体的服务员，负责服务客人。

代码实战：让你的服务器火力全开

现在，让我们通过代码来演示如何使用 cluster 模块。

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

const numCPUs = os.cpus().length; // 获取 CPU 核心数

if (cluster.isMaster) {
  // 主进程
  console.log(`主进程 ${process.pid} 正在运行`);

  // Fork 工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 退出`);
    // 可以选择重新启动工作进程
    cluster.fork();
  });
} else {
  // 工作进程
  http.createServer((req, res) => {
    // 模拟 CPU 密集型任务
    let i = 0;
    while (i < 1e7) {
      i++;
    }

    res.writeHead(200);
    res.end(`你好世界！我是工作进程 ${process.pid}n`);
  }).listen(8000);

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

这段代码做了什么呢？

引入模块： 引入 cluster、http 和 os 模块。os 模块用于获取 CPU 核心数。
判断进程类型： 使用 cluster.isMaster 判断当前进程是主进程还是工作进程。
主进程逻辑：
- 打印主进程的 PID。
- 根据 CPU 核心数，使用 cluster.fork() 创建相应数量的工作进程。
- 监听 exit 事件，当工作进程退出时，重新启动一个新的工作进程，保证服务的可用性。
工作进程逻辑：
- 创建一个 HTTP 服务器，监听 8000 端口。
- 在请求处理函数中，模拟一个 CPU 密集型任务（一个简单的循环）。
- 返回一个简单的 "你好世界！" 响应，并包含工作进程的 PID。
- 打印工作进程的 PID。

运行代码：见证多核的威力

将这段代码保存为 app.js，然后在命令行中运行 node app.js。你会看到类似以下的输出：

主进程 1234 正在运行
工作进程 1235 已启动
工作进程 1236 已启动
工作进程 1237 已启动
工作进程 1238 已启动

(假设你的 CPU 有 4 个核心)

现在，打开你的浏览器，访问 http://localhost:8000。你会看到 "你好世界！" 响应，并且每次刷新页面，工作进程的 PID 可能会不一样，说明不同的工作进程在处理你的请求。

如果没有 cluster 模块，所有的请求都会由同一个进程处理，CPU 密集型任务会阻塞整个进程。而现在，多个工作进程可以并行处理请求，大大提高了服务器的吞吐量。

负载均衡：让每个核心都发挥作用

cluster 模块内置了负载均衡机制，它可以自动将新的连接分配给不同的工作进程。默认情况下，cluster 使用 "round-robin" 算法进行负载均衡，即轮流将连接分配给下一个工作进程。

但是，round-robin 算法并不总是最优的。例如，如果某个工作进程正在处理一个 CPU 密集型任务，它可能无法及时处理新的连接。

为了解决这个问题，cluster 模块还支持 "sticky sessions"（粘性会话）算法。使用粘性会话，可以确保来自同一个客户端的请求始终由同一个工作进程处理。这对于需要维护会话状态的应用程序非常有用。

要启用粘性会话，你需要使用 cluster.setupMaster() 方法，并设置 serialization 选项为 'ipc'。

cluster.setupMaster({
  serialization: 'ipc'
});

代码进阶：优雅地管理工作进程

在实际应用中，我们可能需要更精细地控制工作进程的启动、停止和重启。cluster 模块提供了一些方法来实现这些功能。

cluster.fork()： 创建一个新的工作进程。
worker.kill()： 杀死一个工作进程。
worker.disconnect()： 断开工作进程与主进程的连接，允许工作进程优雅地退出。
worker.process.pid： 获取工作进程的 PID。
worker.id： 获取工作进程的唯一 ID。

下面是一个更复杂的例子，演示如何手动管理工作进程：

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

const numCPUs = os.cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);

  let workers = {};

  // 创建工作进程
  const createWorker = () => {
    const worker = cluster.fork();
    workers[worker.id] = worker;
    console.log(`工作进程 ${worker.process.pid} 已启动`);

    worker.on('exit', (code, signal) => {
      console.log(`工作进程 ${worker.process.pid} 退出，重启中...`);
      delete workers[worker.id];
      createWorker(); // 自动重启
    });

    worker.on('message', (message) => {
      console.log(`主进程收到来自工作进程 ${worker.process.pid} 的消息：`, message);
    });
  };

  for (let i = 0; i < numCPUs; i++) {
    createWorker();
  }

  // 定时向所有工作进程发送消息
  setInterval(() => {
    for (const id in workers) {
      workers[id].send({ type: 'ping', timestamp: Date.now() });
    }
  }, 5000);

  // 监听来自工作进程的消息
  cluster.on('message', (worker, message) => {
    console.log(`主进程收到来自工作进程 ${worker.process.pid} 的消息：`, message);
  });

} else {
  http.createServer((req, res) => {
    // 模拟 CPU 密集型任务
    let i = 0;
    while (i < 1e7) {
      i++;
    }

    res.writeHead(200);
    res.end(`你好世界！我是工作进程 ${process.pid}n`);
    process.send({ type: 'requestHandled', pid: process.pid }); // 向主进程发送消息
  }).listen(8000);

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

  process.on('message', (message) => {
    console.log(`工作进程 ${process.pid} 收到来自主进程的消息：`, message);
    if (message.type === 'ping') {
      console.log(`工作进程 ${process.pid} 收到 ping 消息，时间戳：`, message.timestamp);
    }
  });
}

这个例子中，我们：

使用 workers 对象来管理所有工作进程。
创建 createWorker() 函数来创建新的工作进程，并设置 exit 和 message 事件监听器。
使用 setInterval() 定时向所有工作进程发送消息。
工作进程通过 process.send() 方法向主进程发送消息。

消息传递：主进程与工作进程的沟通桥梁

主进程和工作进程之间可以通过消息传递进行通信。这对于监控工作进程的状态、动态调整配置等场景非常有用。

主进程向工作进程发送消息： 使用 worker.send(message) 方法。
工作进程向主进程发送消息： 使用 process.send(message) 方法。

消息可以是任何可以被序列化为 JSON 的对象。

常见问题与注意事项

端口冲突： 确保所有工作进程监听不同的端口，或者使用主进程来监听端口，然后将连接转发给工作进程。
共享资源： 由于工作进程运行在不同的进程中，它们无法直接共享内存。如果需要共享数据，可以使用 Redis、Memcached 等外部存储。
调试： 调试多进程应用程序可能比较困难。可以使用 Node.js 的调试器，或者使用 console.log() 来输出调试信息。
日志： 集中管理所有工作进程的日志，方便排查问题。
CPU 密集型任务： cluster 模块主要用于处理 CPU 密集型任务。对于 I/O 密集型任务，Node.js 的单线程、非阻塞 I/O 模型已经足够高效。
代码修改： 修改代码后，需要重启所有工作进程才能生效。可以使用 nodemon 等工具来自动重启进程。

总结：拥抱多核，提升性能

cluster 模块是 Node.js 中一个非常强大的工具，它可以让你充分利用多核 CPU 的性能，提高服务器的吞吐量。但是，使用 cluster 模块也需要注意一些问题，例如端口冲突、共享资源、调试等。

总的来说，cluster 模块是一个值得学习和使用的模块，它可以让你的 Node.js 应用程序更加高效、稳定。

表格总结：cluster 模块常用 API

API	描述
`cluster.isMaster`	判断当前进程是否是主进程。
`cluster.isWorker`	判断当前进程是否是工作进程。
`cluster.fork()`	创建一个新的工作进程。
`cluster.setupMaster()`	配置主进程。
`cluster.worker`	获取当前工作进程的 `Worker` 对象。
`cluster.workers`	获取所有活动工作进程的 `Worker` 对象。
`worker.id`	获取工作进程的唯一 ID。
`worker.process.pid`	获取工作进程的 PID。
`worker.kill([signal])`	杀死一个工作进程。
`worker.disconnect()`	断开工作进程与主进程的连接。
`worker.send(message)`	向工作进程发送消息。
`worker.on(event, listener)`	监听工作进程的事件（例如 `'exit'`、`'message'`）。
`process.send(message)`	工作进程向主进程发送消息。

最后的彩蛋：别忘了监控！

光让服务器跑起来还不够，你还需要监控它的运行状态，及时发现和解决问题。可以使用 PM2、Forever 等进程管理工具，它们可以自动重启崩溃的进程，并提供监控功能。

好了，今天的讲座就到这里。希望大家能够学以致用，让你的服务器跑得更快、更稳！如果大家还有什么问题，欢迎在评论区留言，我会尽力解答。下次再见！

发表回复 取消回复

发表回复取消回复