Node.js Cluster模块：高效负载均衡与进程管理

Cluster模块的工作原理

Node.js的cluster模块允许你创建多个工作进程（workers），它们共享服务器端口，但每个进程都在自己的V8实例中运行。这使得应用程序能够实现负载均衡，提高性能和稳定性。cluster模块基于POSIX的集群服务器模型，允许主进程（master）和工作进程（workers）之间的通信。

Worker类

Worker类代表一个工作进程。它是EventEmitter的子类，具有多个事件和方法，用于管理进程的生命周期和通信。

事件：’disconnect’

当工作进程断开连接时，会发出'disconnect'事件。

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

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('disconnect', (worker) => {
    console.log(`Worker ${worker.id} disconnected`);
  });
}

事件：’error’

如果工作进程在启动时发生错误，会发出'error'事件。

cluster.on('error', (error, worker) => {
  console.error(`Error creating worker ${worker.id}: ${error}`);
});

事件：’exit’

当工作进程退出时，会发出'exit'事件。

cluster.on('exit', (worker, code, signal) => {
  console.log(`Worker ${worker.id} exited with code ${code} and signal ${signal}`);
});

事件：’listening’

当工作进程监听端口时，会发出'listening'事件。

worker.on('listening', (address) => {
  console.log(`Worker is now listening on ${address.address}:${address.port}`);
});

事件：’message’

当工作进程发送消息时，会发出'message'事件。

worker.on('message', (message) => {
  console.log(`Received message from worker ${worker.id}: ${message}`);
});

事件：’online’

当工作进程准备就绪并上线时，会发出'online'事件。

cluster.on('online', (worker) => {
  console.log(`Worker ${worker.id} is online`);
});

方法：worker.disconnect()

断开工作进程的连接。

worker.disconnect();

属性：worker.exitedAfterDisconnect

指示工作进程是否在断开连接后退出。

console.log(`Worker ${worker.id} exited after disconnect: ${worker.exitedAfterDisconnect}`);

方法：worker.isConnected()

检查工作进程是否已连接。

console.log(`Worker ${worker.id} is connected: ${worker.isConnected()}`);

方法：worker.isDead()

检查工作进程是否已死亡。

console.log(`Worker ${worker.id} is dead: ${worker.isDead()}`);

方法：worker.kill([signal])

向工作进程发送信号以终止它。

worker.kill('SIGTERM');

方法：worker.process

获取工作进程的底层进程对象。

const process = worker.process;
console.log(`Worker process id: ${process.pid}`);

方法：worker.send(message[, sendHandle[, options]][, callback])

向工作进程发送消息。

worker.send({ hello: 'world' }, (error) => {
  if (error) {
    console.error(`Failed to send message to worker ${worker.id}: ${error}`);
  } else {
    console.log(`Message sent to worker ${worker.id}`);
  }
});

事件：’disconnect’（工作进程视角）

工作进程也可以监听'disconnect'事件，以处理与主进程的连接断开。

process.on('disconnect', () => {
  console.log(`Worker ${process.pid} disconnected from master`);
});

事件：’exit’（工作进程视角）

工作进程可以监听'exit'事件，以处理自身的退出。

process.on('exit', (code) => {
  console.log(`Worker ${process.pid} exited with code ${code}`);
});

事件：’fork’

主进程可以监听'fork'事件，以知道新的工作进程已被创建。

cluster.on('fork', (worker) => {
  console.log(`New worker ${worker.id} forked`);
});

属性：cluster.isMaster

检查当前进程是否为主进程。

if (cluster.isMaster) {
  console.log(`This is the master process`);
}

属性：cluster.isPrimary

检查当前进程是否为主进程或主工作进程。

if (cluster.isPrimary) {
  console.log(`This is the primary worker process`);
}

属性：cluster.isWorker

检查当前进程是否为工作进程。

if (cluster.isWorker) {
  console.log(`This is a worker process`);
}

属性：cluster.schedulingPolicy

获取或设置集群的调度策略。

console.log(`Scheduling policy: ${cluster.schedulingPolicy}`);

属性：cluster.settings

获取集群的设置。

console.log(`Cluster settings: ${JSON.stringify(cluster.settings)}`);

方法：cluster.setupMaster([settings])

设置主进程的监听器和配置。

cluster.setupMaster({
  exec: 'worker.js',
  args: ['arg1', 'arg2'],
  // 其他设置...
});

方法：cluster.setupPrimary([settings])

设置主工作进程的监听器和配置。

cluster.setupPrimary({
  // 设置...
});

方法：cluster.worker

获取主工作进程的引用。

console.log(`Primary worker process id: ${cluster.worker.id}`);

属性：cluster.workers

获取所有工作进程的集合。

console.log(`Workers: ${JSON.stringify(cluster.workers)}`);

事件：’setup’

主进程可以监听'setup'事件，以知道所有工作进程都已设置完毕。

cluster.on('setup', () => {
  console.log(`All workers are set up`);
});

通过使用cluster模块，你可以轻松地将Node.js应用程序扩展到多个CPU核心，从而提高应用程序的性能和可靠性。这些示例展示了如何使用cluster模块的基本功能，包括创建工作进程、监听事件和发送消息。通过这些功能，你可以构建一个强大的Node.js应用程序，它能够处理大量的并发连接和任务。

当然可以。cluster模块在Node.js中提供了一个强大的工具，用于在多核CPU上实现应用程序的负载均衡和高效运行。以下是一些应用场景，以及如何在这些场景中使用cluster模块的示例。

应用场景：高并发Web服务器

场景描述：
假设你正在运行一个高流量的Web应用程序，该应用程序需要处理大量的并发请求。为了确保应用程序的性能和响应能力，你需要在多个CPU核心上分配工作负载。

解决方案：
使用cluster模块创建多个工作进程，每个进程都监听同一个端口，但是独立地处理请求。

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

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

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

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    // 可以在这里重新创建工作进程
  });
} else {
  // 工作进程的代码
  http.createServer((req, res) => {
    res.end(`Hello from worker ${process.pid}!`);
  }).listen(3000, () => {
    console.log(`Worker ${process.pid} started`);
  });
}

应用场景：实时数据处理和报告

场景描述：
你的应用程序需要实时处理大量数据，并定期生成报告。你希望利用多个CPU核心来加速数据处理，并保持前端界面的实时更新。

解决方案：
使用cluster模块创建一个主进程和多个工作进程，其中工作进程负责数据处理，而主进程负责管理界面和报告的生成。

// master.js
const cluster = require('cluster');
const fs = require('fs');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`Master process ${process.pid} is running`);

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

  // 定期生成报告
  setInterval(() => {
    const report = generateReport();
    fs.writeFileSync('report.txt', report);
  }, 60000); // 每分钟生成一次报告
} else {
  // 工作进程的代码
  process.on('message', (data) => {
    // 处理数据
    const result = processData(data);
    process.send(result);
  });
}

// worker.js
const process = require('process');

process.on('message', (data) => {
  // 模拟数据处理
  const result = {
    ...data,
    processed: true
  };
  process.send(result);
});

应用场景：负载均衡的API服务

场景描述：
你需要提供一个API服务，该服务能够处理来自不同客户端的请求，并在多个工作进程之间实现负载均衡。

解决方案：
使用cluster模块和HTTP服务器，创建一个可以自动在工作进程之间分配请求的API服务。

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

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

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

  // 监听工作进程的在线状态
  cluster.on('online', (worker) => {
    console.log(`Worker ${worker.process.pid} is online`);
  });
} else {
  // 工作进程的代码
  http.createServer((req, res) => {
    // 处理API请求
    res.end(`Worker ${process.pid} handled the request`);
  }).listen(8080, () => {
    console.log(`Worker ${process.pid} started`);
  });
}

通过这些应用场景，我们可以看到cluster模块如何帮助我们在Node.js中实现多进程架构，从而提高应用程序的性能和可靠性。无论是处理高并发请求、实时数据处理还是提供负载均衡的API服务，cluster模块都提供了一种简单而有效的方法来利用多核CPU的优势。

原文链接：https://juejin.cn/post/7357674793792127016 作者：前端孺子牛