JavaScript内核与高级编程之：`Node.js`的`Cluster`模块：如何利用多核`CPU`处理高并发。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众老爷，晚上好！今天咱们聊聊 Node.js 里一个相当给力的模块：Cluster。说白了，就是教 Node.js 怎么学会“影分身之术”，充分利用你电脑里那几颗甚至几十颗 CPU 的核心，让你的服务器面对高并发也能稳如老狗。

一、单线程的无奈：Node.js 的“独木桥”

Node.js 以其单线程事件循环机制著称，这种机制在 I/O 密集型应用中表现出色。但想象一下，所有请求都得挤在一个线程里排队处理，就像独木桥上堵满了人，一旦有个“大胖子”（耗时操作）卡住，后面的人都得跟着遭殃。

举个例子，咱们写一个简单的 HTTP 服务器：

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Hello, World!');
  } else if (req.url === '/intensive') {
    // 模拟一个耗时的 CPU 密集型操作
    let sum = 0;
    for (let i = 0; i < 1000000000; i++) {
      sum += i;
    }
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end(`Intensive task completed. Sum: ${sum}`);
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not Found');
  }
});

const port = 3000;
server.listen(port, () => {
  console.log(`Server running at http://localhost:${port}/`);
});

这段代码很简单，访问 / 返回 "Hello, World!"，访问 /intensive 会执行一个耗时的循环计算。

现在，打开浏览器，同时访问 / 和 /intensive。你会发现，访问 / 的请求会被 /intensive 的耗时操作阻塞，直到 /intensive 完成后才能响应。这说明什么？单线程的 Node.js 在处理 CPU 密集型任务时，会严重影响其他请求的响应速度。

二、Cluster 模块：Node.js 的“影分身之术”

Cluster 模块就是来解决这个问题的。它可以让你创建多个 Node.js 进程，每个进程都运行着相同的代码，但拥有独立的事件循环和内存空间。这样，就可以充分利用多核 CPU 的并行处理能力，让你的服务器不再“瘸腿”。

Cluster 模块的工作方式可以简单概括为：

主进程 (Master): 负责管理工作进程，监听端口，并将连接分发给工作进程。
工作进程 (Worker): 负责处理实际的请求。

三、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} 正在运行`);

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

  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
    // 可以选择重新启动工作进程
    // cluster.fork();
  });
} else {
  // 工作进程执行服务器逻辑
  const server = http.createServer((req, res) => {
    if (req.url === '/') {
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.end(`Hello, World! from Worker ${process.pid}`);
    } else if (req.url === '/intensive') {
      let sum = 0;
      for (let i = 0; i < 1000000000; i++) {
        sum += i;
      }
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.end(`Intensive task completed by Worker ${process.pid}. Sum: ${sum}`);
    } else {
      res.writeHead(404, { 'Content-Type': 'text/plain' });
      res.end('Not Found');
    }
  });

  const port = 3000;
  server.listen(port, () => {
    console.log(`工作进程 ${process.pid} 正在监听端口 ${port}`);
  });
}

这段代码做了什么？

判断进程类型： cluster.isMaster 判断当前进程是否为主进程。
主进程逻辑： 如果是主进程，就根据 CPU 核心数创建相应数量的工作进程。cluster.fork() 会创建一个新的 Node.js 进程，并运行相同的脚本。
工作进程逻辑： 如果是工作进程，就执行服务器逻辑，监听端口，处理请求。

现在运行这段代码，你会发现，启动了多个 Node.js 进程，每个进程都监听着相同的端口。当你访问 /intensive 时，不会再阻塞其他请求，因为不同的请求会被分配给不同的工作进程处理。

四、Cluster 的负载均衡策略：谁来分饼？

主进程如何将请求分发给工作进程？Cluster 模块提供了两种负载均衡策略：

Round-Robin (默认): 主进程按顺序将连接分配给工作进程。就像餐厅服务员依次给客人上菜一样。
Sticky-Session: 主进程根据客户端的 IP 地址，将来自同一个客户端的连接分配给同一个工作进程。这样可以保持会话状态，避免频繁切换工作进程带来的性能损耗。

可以通过设置 cluster.schedulingPolicy 来选择负载均衡策略：

// 使用 Sticky-Session 策略
cluster.schedulingPolicy = cluster.SCHED_RR; // 使用Round-Robin

五、Cluster 的进程管理：如何保证“影分身”的安全？

在实际应用中，工作进程可能会因为各种原因崩溃或退出。为了保证服务的可用性，我们需要对工作进程进行监控和管理。

Cluster 模块提供了 exit 事件，当工作进程退出时，会触发该事件。我们可以在 exit 事件中重新启动工作进程，以保证服务的持续运行：

cluster.on('exit', (worker, code, signal) => {
  console.log(`工作进程 ${worker.process.pid} 已退出`);
  // 重新启动工作进程
  console.log('开始一个新的工作进程');
  cluster.fork();
});

这段代码会在工作进程退出后，立即启动一个新的工作进程，从而保证服务的可用性。但是，如果工作进程频繁崩溃，可能会导致系统资源耗尽。因此，我们需要对重新启动的频率进行限制，避免出现“雪崩”效应。

六、Cluster 的通信：如何让“影分身”协同作战？

在某些情况下，我们需要在主进程和工作进程之间进行通信。例如，主进程需要收集工作进程的统计信息，或者工作进程需要通知主进程进行某些操作。

Cluster 模块提供了 worker.send() 和 process.on('message') 方法，用于在主进程和工作进程之间发送消息：

// 主进程向工作进程发送消息
for (const id in cluster.workers) {
  cluster.workers[id].send({ type: 'start_task', data: 'some data' });
}

// 工作进程接收消息
process.on('message', (message) => {
  if (message.type === 'start_task') {
    console.log(`Worker ${process.pid} received task: ${message.data}`);
    // 执行任务
  }
});

这段代码演示了主进程如何向所有工作进程发送 start_task 消息，以及工作进程如何接收并处理该消息。

七、Cluster 的高级应用：让“影分身”更强大

除了基本用法外，Cluster 模块还可以用于实现更高级的功能，例如：

零停机重启： 在不中断服务的情况下，更新服务器代码。
动态调整工作进程数量： 根据服务器负载，动态增加或减少工作进程的数量。
共享内存： 在工作进程之间共享数据，提高性能。

这些高级用法需要更深入的了解 Cluster 模块的原理和 API，以及对 Node.js 的事件循环机制有更透彻的理解。

八、Cluster 的注意事项：使用“影分身之术”的禁忌

在使用 Cluster 模块时，需要注意以下几点：

状态共享： 工作进程之间是独立的，不能直接共享状态。如果需要共享状态，可以使用外部存储，例如 Redis 或 Memcached。
端口占用： 主进程和工作进程都监听相同的端口，需要确保端口没有被其他进程占用。
资源消耗： 创建多个工作进程会消耗更多的 CPU 和内存资源，需要根据服务器的配置进行调整。
调试难度： 多进程应用的调试比单进程应用更复杂，需要使用专门的调试工具。

九、总结：Cluster，Node.js 的“多核加速器”

Cluster 模块是 Node.js 中一个非常重要的模块，它可以让你充分利用多核 CPU 的并行处理能力，提高服务器的性能和可靠性。但是，在使用 Cluster 模块时，需要注意一些细节，避免出现问题。

总的来说，Cluster 模块就像 Node.js 的“多核加速器”，让你的服务器在高并发场景下也能游刃有余。掌握 Cluster 模块，是成为一名优秀的 Node.js 开发者的必备技能。

十、代码示例:

为了更清晰地说明，这里提供一个完整的代码示例，包含主进程和工作进程的逻辑：

// cluster_example.js
const cluster = require('cluster');
const http = require('http');
const os = require('os');

const numCPUs = os.cpus().length;
const port = 3000;

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

    // 监听工作进程的在线状态
    cluster.on('online', (worker) => {
        console.log(`工作进程 ${worker.process.pid} 已启动`);
    });

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

    cluster.on('exit', (worker, code, signal) => {
        console.log(`工作进程 ${worker.process.pid} 已退出,退出码: ${code}, 信号: ${signal}`);
        console.log('重新启动一个新的工作进程');
        cluster.fork(); // 自动重启，保持工作进程的数量
    });

    // 主进程发送消息给所有工作进程
    setInterval(() => {
        for (const id in cluster.workers) {
            cluster.workers[id].send({ type: 'heartbeat', timestamp: Date.now() });
        }
    }, 5000); // 每5秒发送一次心跳

} else {
    // 工作进程执行服务器逻辑
    const server = http.createServer((req, res) => {
        if (req.url === '/') {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end(`Hello, World! from Worker ${process.pid}`);
        } else if (req.url === '/intensive') {
            // 模拟一个耗时的 CPU 密集型操作
            let sum = 0;
            const startTime = Date.now();
            for (let i = 0; i < 1000000000; i++) {
                sum += i;
            }
            const endTime = Date.now();
            const duration = endTime - startTime;

            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end(`Intensive task completed by Worker ${process.pid}. Sum: ${sum}. Took ${duration}ms`);
        } else if (req.url === '/error') {
            //模拟异常
            throw new Error('模拟工作进程异常');

        } else {
            res.writeHead(404, { 'Content-Type': 'text/plain' });
            res.end('Not Found');
        }
    });

    server.on('error', (err) => {
        console.error(`工作进程 ${process.pid} 遇到错误:`, err);
        // 可以选择优雅地关闭服务器
        process.exit(1); // 退出进程，主进程会重启
    });

    server.listen(port, () => {
        console.log(`工作进程 ${process.pid} 正在监听端口 ${port}`);
    });

    // 工作进程监听主进程的消息
    process.on('message', (message) => {
        if (message.type === 'heartbeat') {
            console.log(`工作进程 ${process.pid} 收到心跳消息, 时间戳: ${message.timestamp}`);
        }
        // 其他消息处理逻辑
    });

    // 处理未捕获的异常
    process.on('uncaughtException', (err) => {
        console.error(`工作进程 ${process.pid} 捕获到未捕获的异常:`, err);
        // 记录错误日志
        // 可以选择通知主进程
        // 优雅地关闭服务器
        process.exit(1); // 退出进程，主进程会重启
    });
}

代码解释:

错误处理: 增加了 server.on('error') 和 process.on('uncaughtException') 来处理服务器和进程级别的错误。如果工作进程遇到错误,则退出，主进程会重新启动一个新的工作进程。
端口监听错误: 检查端口是否被占用，避免服务器启动失败。
心跳机制: 主进程定时向工作进程发送心跳消息，工作进程收到心跳消息后会打印日志。这可以用来监控工作进程的健康状态。
自动重启： 在 cluster.on('exit') 中，自动重启退出的工作进程，保持工作进程的数量。
进程启动状态监听: 监听 cluster.on('online') ,记录工作进程启动状态

如何运行：

保存为 cluster_example.js。
在命令行中运行 node cluster_example.js。
打开浏览器访问 http://localhost:3000/，http://localhost:3000/intensive 和 http://localhost:3000/error，观察控制台输出。

表格总结：

特性	描述
`cluster.isMaster`	判断当前进程是否为主进程。
`cluster.fork()`	衍生一个新的工作进程。
`cluster.workers`	包含所有活动工作进程的对象。
`worker.process.pid`	工作进程的进程 ID。
`cluster.on('exit')`	监听工作进程退出事件。
`worker.send(message)`	向工作进程发送消息。
`process.on('message')`	工作进程监听主进程发送的消息。
`cluster.schedulingPolicy`	设置负载均衡策略（`SCHED_RR` 或 `SCHED_NONE`）。
`process.on('uncaughtException')`	捕获未捕获的异常，防止进程崩溃。
`server.on('error')`	监听服务器错误，例如端口占用。

希望这次讲座能帮到你，各位观众老爷，下次再见！

发表回复 取消回复

发表回复取消回复