Cluster (集群) | Node.js v26.0.0 文档

Cluster (集群)#

Node.js 进程集群可用于运行多个 Node.js 实例，从而在应用程序线程之间分配工作负载。当不需要进程隔离时，请改用 worker_threads 模块，它允许在单个 Node.js 实例中运行多个应用程序线程。

cluster 模块可以轻松创建共享服务器端口的子进程。

import cluster from 'node:cluster';
import http from 'node:http';
import { availableParallelism } from 'node:os';
import process from 'node:process';

const numCPUs = availableParallelism();

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

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`);
  });
} else {
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('hello world\n');
  }).listen(8000);

  console.log(`Worker ${process.pid} started`);
}
const cluster = require('node:cluster');
const http = require('node:http');
const numCPUs = require('node:os').availableParallelism();
const process = require('node:process');

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

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`);
  });
} else {
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('hello world\n');
  }).listen(8000);

  console.log(`Worker ${process.pid} started`);
}

运行 Node.js 现在将在工作进程（workers）之间共享 8000 端口。

$ node server.js
Primary 3596 is running
Worker 4324 started
Worker 4520 started
Worker 6056 started
Worker 5644 started

在 Windows 上，目前还无法在工作进程中设置命名管道服务器。

工作原理#

工作进程是使用 child_process.fork() 方法生成的，因此它们可以通过 IPC（进程间通信）与父进程通信，并来回传递服务器句柄。

cluster 模块支持两种分配传入连接的方法。

第一种（也是除 Windows 外所有平台上的默认方法）是轮询（round-robin）方法，主进程在端口上监听，接受新连接，并以轮询方式将它们分配给工作进程，同时内置了一些智能机制以避免工作进程过载。

第二种方法是主进程创建监听套接字并将其发送给感兴趣的工作进程。然后，工作进程直接接受传入的连接。

理论上，第二种方法应该能提供最佳性能。但在实践中，由于操作系统调度程序的不确定性，分布往往非常不平衡。据观察，在某些负载情况下，总共八个进程中，超过 70% 的连接最终集中在仅仅两个进程上。

由于 server.listen() 将大部分工作移交给了主进程，因此在以下三种情况下，普通 Node.js 进程和集群工作进程的行为会有所不同：

server.listen({fd: 7})：由于消息被传递给主进程，因此将监听**父进程中**的文件描述符 7，并将该句柄传递给工作进程，而不是监听工作进程认为的编号为 7 的文件描述符。
server.listen(handle)：显式监听句柄将导致工作进程使用提供的句柄，而不是与主进程通信。
server.listen(0)：通常这会导致服务器在随机端口上监听。然而，在集群中，每个工作进程每次执行 listen(0) 时都会收到相同的“随机”端口。本质上，第一次是随机的，但之后是可预测的。要监听唯一端口，请根据集群工作进程 ID 生成端口号。

Node.js 不提供路由逻辑。因此，设计应用程序时，确保它不要过分依赖内存数据对象（如会话和登录信息）非常重要。

由于工作进程都是独立的进程，它们可以根据程序的需要被杀死或重新生成，而不会影响其他工作进程。只要还有工作进程存活，服务器就会继续接受连接。如果没有存活的工作进程，现有连接将被丢弃，新连接将被拒绝。不过，Node.js 不会自动管理工作进程的数量。根据自身需求管理工作进程池是应用程序的责任。

虽然 node:cluster 模块的主要用例是网络，但它也可用于其他需要工作进程的用例。

类: `Worker`#

新增于: v0.7.0

扩展自：<EventEmitter>

Worker 对象包含关于工作进程的所有公共信息和方法。在主进程中，可以通过 cluster.workers 获取；在工作进程中，可以通过 cluster.worker 获取。

事件：`'disconnect'`#

添加于：v0.7.7

类似于 cluster.on('disconnect') 事件，但特定于此工作进程。

cluster.fork().on('disconnect', () => {
  // Worker has disconnected
});

事件：`'error'`#

添加于：v0.7.3

此事件与 child_process.fork() 提供的事件相同。

在工作进程内，也可以使用 process.on('error')。

事件: `'exit'`#

引入于：v0.11.2

code <number> 如果正常退出，则为退出代码。
signal <string> 导致进程被杀死的信号名称（例如 'SIGHUP'）。

类似于 cluster.on('exit') 事件，但特定于此工作进程。

import cluster from 'node:cluster';

if (cluster.isPrimary) {
  const worker = cluster.fork();
  worker.on('exit', (code, signal) => {
    if (signal) {
      console.log(`worker was killed by signal: ${signal}`);
    } else if (code !== 0) {
      console.log(`worker exited with error code: ${code}`);
    } else {
      console.log('worker success!');
    }
  });
}
const cluster = require('node:cluster');

if (cluster.isPrimary) {
  const worker = cluster.fork();
  worker.on('exit', (code, signal) => {
    if (signal) {
      console.log(`worker was killed by signal: ${signal}`);
    } else if (code !== 0) {
      console.log(`worker exited with error code: ${code}`);
    } else {
      console.log('worker success!');
    }
  });
}

事件：`'listening'`#

新增于: v0.7.0

address <Object>

类似于 cluster.on('listening') 事件，但特定于此工作进程。

cluster.fork().on('listening', (address) => {
  // Worker is listening
});
cluster.fork().on('listening', (address) => {
  // Worker is listening
});

它不会在工作进程中触发。

事件: `'message'`#

新增于: v0.7.0

message <Object>
handle <undefined> | <Object>

类似于 cluster 的 'message' 事件，但特定于此工作进程。

在工作进程内，也可以使用 process.on('message')。

参见 process 事件：'message'。

下面是一个使用消息系统的示例。它在主进程中保持一个计数器，记录工作进程接收到的 HTTP 请求总数：

import cluster from 'node:cluster';
import http from 'node:http';
import { availableParallelism } from 'node:os';
import process from 'node:process';

if (cluster.isPrimary) {

  // Keep track of http requests
  let numReqs = 0;
  setInterval(() => {
    console.log(`numReqs = ${numReqs}`);
  }, 1000);

  // Count requests
  function messageHandler(msg) {
    if (msg.cmd && msg.cmd === 'notifyRequest') {
      numReqs += 1;
    }
  }

  // Start workers and listen for messages containing notifyRequest
  const numCPUs = availableParallelism();
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  for (const id in cluster.workers) {
    cluster.workers[id].on('message', messageHandler);
  }

} else {

  // Worker processes have a http server.
  http.Server((req, res) => {
    res.writeHead(200);
    res.end('hello world\n');

    // Notify primary about the request
    process.send({ cmd: 'notifyRequest' });
  }).listen(8000);
}
const cluster = require('node:cluster');
const http = require('node:http');
const numCPUs = require('node:os').availableParallelism();
const process = require('node:process');

if (cluster.isPrimary) {

  // Keep track of http requests
  let numReqs = 0;
  setInterval(() => {
    console.log(`numReqs = ${numReqs}`);
  }, 1000);

  // Count requests
  function messageHandler(msg) {
    if (msg.cmd && msg.cmd === 'notifyRequest') {
      numReqs += 1;
    }
  }

  // Start workers and listen for messages containing notifyRequest
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  for (const id in cluster.workers) {
    cluster.workers[id].on('message', messageHandler);
  }

} else {

  // Worker processes have a http server.
  http.Server((req, res) => {
    res.writeHead(200);
    res.end('hello world\n');

    // Notify primary about the request
    process.send({ cmd: 'notifyRequest' });
  }).listen(8000);
}

事件: `'online'`#

新增于: v0.7.0

类似于 cluster.on('online') 事件，但特定于此工作进程。

cluster.fork().on('online', () => {
  // Worker is online
});

它不会在工作进程中触发。

`worker.disconnect()`#

添加于：v0.7.7

历史

版本	变更
v7.3.0	该方法现在返回对 `worker` 的引用。

返回：<cluster.Worker> 对 worker 的引用。

在工作进程中，此函数将关闭所有服务器，等待这些服务器上的 'close' 事件，然后断开 IPC 通道。

在主进程中，会向工作进程发送一条内部消息，使其调用自身的 .disconnect()。

会导致 .exitedAfterDisconnect 被设置。

服务器关闭后，它将不再接受新连接，但连接可以由任何其他正在监听的工作进程接受。现有连接将照常关闭。当不再有连接存在时（参见 server.close()），通往该工作进程的 IPC 通道将关闭，从而允许其优雅地结束。

上述内容仅适用于服务器连接；客户端连接不会被工作进程自动关闭，并且 disconnect 在退出前不会等待客户端连接关闭。

在工作进程中，存在 process.disconnect，但它不是此函数，而是 disconnect()。

由于长连接可能会阻止工作进程断开，因此发送一条消息可能会很有用，以便可以采取特定于应用程序的操作来关闭它们。实现超时机制（如果经过一段时间后仍未触发 'disconnect' 事件，则杀死工作进程）也可能很有用。

if (cluster.isPrimary) {
  const worker = cluster.fork();
  let timeout;

  worker.on('listening', (address) => {
    worker.send('shutdown');
    worker.disconnect();
    timeout = setTimeout(() => {
      worker.kill();
    }, 2000);
  });

  worker.on('disconnect', () => {
    clearTimeout(timeout);
  });

} else if (cluster.isWorker) {
  const net = require('node:net');
  const server = net.createServer((socket) => {
    // Connections never end
  });

  server.listen(8000);

  process.on('message', (msg) => {
    if (msg === 'shutdown') {
      // Initiate graceful close of any connections to server
    }
  });
}

`worker.exitedAfterDisconnect`#

添加于：v6.0.0

类型：<boolean>

如果工作进程由于 .disconnect() 而退出，则此属性为 true。如果工作进程以任何其他方式退出，则为 false。如果工作进程尚未退出，则为 undefined。

布尔值 worker.exitedAfterDisconnect 允许区分主动退出和意外退出，主进程可以根据此值选择是否重启工作进程。

cluster.on('exit', (worker, code, signal) => {
  if (worker.exitedAfterDisconnect === true) {
    console.log('Oh, it was just voluntary – no need to worry');
  }
});

// kill worker
worker.kill();

`worker.id`#

添加于：v0.8.0

类型: <integer>

每个新工作进程都有其唯一的 id，此 id 存储在 id 属性中。

当工作进程存活时，这就是它在 cluster.workers 中索引的键。

`worker.isConnected()`#

始于：v0.11.14

如果工作进程通过其 IPC 通道连接到主进程，则此函数返回 true，否则返回 false。工作进程在创建后即连接到主进程。在 'disconnect' 事件触发后，它将断开连接。

`worker.isDead()`#

始于：v0.11.14

如果工作进程的进程已终止（由于退出或收到信号），此函数返回 true。否则，返回 false。

import cluster from 'node:cluster';
import http from 'node:http';
import { availableParallelism } from 'node:os';
import process from 'node:process';

const numCPUs = availableParallelism();

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

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('fork', (worker) => {
    console.log('worker is dead:', worker.isDead());
  });

  cluster.on('exit', (worker, code, signal) => {
    console.log('worker is dead:', worker.isDead());
  });
} else {
  // Workers can share any TCP connection. In this case, it is an HTTP server.
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Current process\n ${process.pid}`);
    process.kill(process.pid);
  }).listen(8000);
}
const cluster = require('node:cluster');
const http = require('node:http');
const numCPUs = require('node:os').availableParallelism();
const process = require('node:process');

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

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('fork', (worker) => {
    console.log('worker is dead:', worker.isDead());
  });

  cluster.on('exit', (worker, code, signal) => {
    console.log('worker is dead:', worker.isDead());
  });
} else {
  // Workers can share any TCP connection. In this case, it is an HTTP server.
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Current process\n ${process.pid}`);
    process.kill(process.pid);
  }).listen(8000);
}

`worker.kill([signal])`#

新增于: v0.9.12

signal <string> 发送给工作进程的终止信号名称。默认： 'SIGTERM'

此函数将杀死工作进程。在主进程中，它通过断开 worker.process 来实现，断开后使用 signal 杀掉进程。在工作进程内，它通过使用 signal 杀死自身来实现。

kill() 函数会杀死工作进程，而不等待优雅地断开连接，其行为与 worker.process.kill() 相同。

出于向后兼容性考虑，此方法别名为 worker.destroy()。

在工作进程中，存在 process.kill()，但它不是此函数，而是 kill()。

`worker.process`#

新增于: v0.7.0

类型：<ChildProcess>

所有工作进程均使用 child_process.fork() 创建，该函数返回的对象存储为 .process。在工作进程内，存储的是全局 process 对象。

参见：子进程模块。

如果 process 上发生 'disconnect' 事件且 .exitedAfterDisconnect 不为 true，则工作进程将调用 process.exit(0)。这可以防止意外断开连接。

`worker.send(message[, sendHandle[, options]][, callback])`#

新增于: v0.7.0

历史

版本	变更
v4.0.0	现在支持 `callback` 参数。

message <Object>
sendHandle <Handle>
options <Object> options 参数（如果存在）是一个对象，用于参数化某些类型句柄的发送。options 支持以下属性：
- keepOpen <boolean> 传递 net.Socket 实例时可以使用此值。当为 true 时，套接字在发送进程中保持打开状态。默认： false。
callback <Function>
返回：<boolean>

向工作进程或主进程发送消息，可选择附带一个句柄。

在主进程中，这将向特定工作进程发送消息。它等同于 ChildProcess.send()。

在工作进程中，这将向主进程发送消息。它等同于 process.send()。

此示例将回显主进程发送的所有消息：

if (cluster.isPrimary) {
  const worker = cluster.fork();
  worker.send('hi there');

} else if (cluster.isWorker) {
  process.on('message', (msg) => {
    process.send(msg);
  });
}

事件：`'disconnect'`#

添加于：v0.7.9

worker <cluster.Worker>

在工作进程 IPC 通道断开后触发。这可能发生在工作进程优雅退出、被杀死或手动断开连接（例如使用 worker.disconnect()）时。

'disconnect' 和 'exit' 事件之间可能存在延迟。这些事件可用于检测进程是否卡在清理过程中，或者是否存在长期存活的连接。

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

事件：`'exit'`#

添加于：v0.7.9

worker <cluster.Worker>
code <number> 如果正常退出，则为退出代码。
signal <string> 导致进程被杀死的信号名称（例如 'SIGHUP'）。

当任何工作进程死亡时，cluster 模块将触发 'exit' 事件。

这可用于通过再次调用 .fork() 来重启工作进程。

cluster.on('exit', (worker, code, signal) => {
  console.log('worker %d died (%s). restarting...',
              worker.process.pid, signal || code);
  cluster.fork();
});

参见 child_process 事件：'exit'。

事件：`'fork'`#

新增于: v0.7.0

worker <cluster.Worker>

当生成新的工作进程时，cluster 模块将触发 'fork' 事件。这可用于记录工作进程活动并创建自定义超时。

const timeouts = [];
function errorMsg() {
  console.error('Something must be wrong with the connection ...');
}

cluster.on('fork', (worker) => {
  timeouts[worker.id] = setTimeout(errorMsg, 2000);
});
cluster.on('listening', (worker, address) => {
  clearTimeout(timeouts[worker.id]);
});
cluster.on('exit', (worker, code, signal) => {
  clearTimeout(timeouts[worker.id]);
  errorMsg();
});

事件：`'listening'`#

新增于: v0.7.0

worker <cluster.Worker>
address <Object>

在工作进程中调用 listen() 后，当服务器上触发 'listening' 事件时，主进程中的 cluster 上也会触发 'listening' 事件。

事件处理程序执行时带有两个参数：worker 包含工作进程对象，address 对象包含以下连接属性：address、port 和 addressType。如果工作进程正在监听多个地址，这非常有用。

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

addressType 为以下值之一：

4 (TCPv4)
6 (TCPv6)
-1 (Unix 域套接字)
'udp4' 或 'udp6' (UDPv4 或 UDPv6)

事件: `'message'`#

添加于：v2.5.0

历史

版本	变更
v6.0.0	现在传入了 `worker` 参数；详情见下文。

worker <cluster.Worker>
message <Object>
handle <undefined> | <Object>

当集群主进程收到来自任何工作进程的消息时触发。

参见 child_process 事件：'message'。

事件：`'online'`#

新增于: v0.7.0

worker <cluster.Worker>

生成新工作进程后，工作进程应回复在线消息。主进程收到在线消息后将触发此事件。'fork' 和 'online' 之间的区别在于：fork 在主进程生成工作进程时触发，而 'online' 在工作进程运行时触发。

cluster.on('online', (worker) => {
  console.log('Yay, the worker responded after it was forked');
});

事件：`'setup'`#

添加于：v0.7.1

settings <Object>

每次调用 .setupPrimary() 时触发。

settings 对象是调用 .setupPrimary() 时刻的 cluster.settings 对象，仅供参考，因为在同一个 tick 内可以多次调用 .setupPrimary()。

如果准确性很重要，请使用 cluster.settings。

`cluster.disconnect([callback])`#

添加于：v0.7.7

callback <Function> 当所有工作进程断开连接且句柄关闭时调用。

对 cluster.workers 中的每个工作进程调用 .disconnect()。

当它们断开连接时，所有内部句柄都将关闭，从而允许主进程在没有其他待处理事件的情况下优雅地结束。

此方法接受一个可选的回调参数，该回调将在完成时调用。

此方法只能从主进程调用。

`cluster.fork([env])`#

新增于: v0.6.0

env <Object> 要添加到工作进程环境中的键值对。
返回：<cluster.Worker>

生成一个新的工作进程。

此方法只能从主进程调用。

`cluster.isMaster`#

添加于：v0.8.1 弃用于：v16.0.0

稳定性：0 - 已弃用

cluster.isPrimary 的弃用别名。

`cluster.isPrimary`#

新增于: v16.0.0

类型：<boolean>

如果该进程是主进程，则为 true。这是由 process.env.NODE_UNIQUE_ID 决定的。如果 process.env.NODE_UNIQUE_ID 未定义，则 isPrimary 为 true。

`cluster.isWorker`#

新增于: v0.6.0

类型：<boolean>

如果该进程不是主进程，则为 true（它是 cluster.isPrimary 的取反）。

`cluster.schedulingPolicy`#

引入于：v0.11.2

调度策略，可以是 cluster.SCHED_RR（轮询）或 cluster.SCHED_NONE（交给操作系统处理）。这是一个全局设置，一旦生成第一个工作进程或调用了 .setupPrimary()（以先发生的为准），即被锁定。

SCHED_RR 是除 Windows 外所有操作系统上的默认设置。一旦 libuv 能够有效分配 IOCP 句柄而不会导致严重的性能损耗，Windows 将切换到 SCHED_RR。

cluster.schedulingPolicy 也可以通过环境变量 NODE_CLUSTER_SCHED_POLICY 设置。有效值为 'rr' 和 'none'。

`cluster.settings`#

添加于：v0.7.1

历史

版本	变更
v13.2.0, v12.16.0	现在支持 `serialization` 选项。
v9.5.0	现在支持 `cwd` 选项。
v9.4.0	现在支持 `windowsHide` 选项。
v8.2.0	现在支持 `inspectPort` 选项。
v6.4.0	现在支持 `stdio` 选项。

类型：<Object>
execArgv <string[]> 传递给 Node.js 可执行文件的字符串参数列表。默认： process.execArgv。
exec <string> 工作进程文件的路径。默认： process.argv[1]。
args <string[]> 传递给工作进程的字符串参数。默认： process.argv.slice(2)。
cwd <string> 工作进程的当前工作目录。默认： undefined（继承自父进程）。
serialization <string> 指定进程间发送消息时使用的序列化类型。可能的值为 'json' 和 'advanced'。有关详细信息，请参阅 child_process 的高级序列化。默认： false。
silent <boolean> 是否将输出发送到父进程的 stdio。默认： false。
stdio <Array> 配置已生成进程的 stdio。由于集群模块依赖 IPC 才能运行，此配置必须包含 'ipc' 条目。提供此选项时，它会覆盖 silent。参见 child_process.spawn() 的 stdio。
uid <number> 设置进程的用户身份。（参见 setuid(2)。）
gid <number> 设置进程的组身份。（参见 setgid(2)。）
inspectPort <number> | <Function> 设置工作进程的检查器端口。这可以是一个数字，或一个不接受参数且返回数字的函数。默认情况下，每个工作进程都有自己的端口，从主进程的 process.debugPort 递增。
windowsHide <boolean> 隐藏在 Windows 系统上通常会创建的生成进程的控制台窗口。默认： false。

调用 .setupPrimary()（或 .fork()）后，此 settings 对象将包含这些设置，包括默认值。

此对象不打算手动更改或设置。

`cluster.setupMaster([settings])`#

添加于：v0.7.1 弃用于：v16.0.0

历史

版本	变更
v6.4.0	现在支持 `stdio` 选项。

稳定性：0 - 已弃用

.setupPrimary() 的弃用别名。

`cluster.setupPrimary([settings])`#

新增于: v16.0.0

settings <Object> 参见 cluster.settings。

setupPrimary 用于更改默认的 'fork' 行为。调用后，设置将出现在 cluster.settings 中。

任何设置更改仅影响未来对 .fork() 的调用，对已在运行的工作进程无效。

唯一不能通过 .setupPrimary() 设置的工作进程属性是传递给 .fork() 的 env。

上述默认值仅适用于首次调用；后续调用的默认值是调用 cluster.setupPrimary() 时的当前值。

import cluster from 'node:cluster';

cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'https'],
  silent: true,
});
cluster.fork(); // https worker
cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'http'],
});
cluster.fork(); // http worker
const cluster = require('node:cluster');

cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'https'],
  silent: true,
});
cluster.fork(); // https worker
cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'http'],
});
cluster.fork(); // http worker

此方法只能从主进程调用。

`cluster.worker`#

新增于: v0.7.0

类型：<Object>

对当前工作进程对象的引用。在主进程中不可用。

import cluster from 'node:cluster';

if (cluster.isPrimary) {
  console.log('I am primary');
  cluster.fork();
  cluster.fork();
} else if (cluster.isWorker) {
  console.log(`I am worker #${cluster.worker.id}`);
}
const cluster = require('node:cluster');

if (cluster.isPrimary) {
  console.log('I am primary');
  cluster.fork();
  cluster.fork();
} else if (cluster.isWorker) {
  console.log(`I am worker #${cluster.worker.id}`);
}

`cluster.workers`#

新增于: v0.7.0

类型：<Object>

一个存储活动工作进程对象的哈希表，由 id 字段键入。这使得遍历所有工作进程变得容易。它仅在主进程中可用。

工作进程在断开连接并退出后，会从 cluster.workers 中移除。这两个事件的先后顺序无法预先确定。但是，可以保证从 cluster.workers 列表中移除的操作会在最后一个 'disconnect' 或 'exit' 事件触发之前发生。

import cluster from 'node:cluster';

for (const worker of Object.values(cluster.workers)) {
  worker.send('big announcement to all workers');
}
const cluster = require('node:cluster');

for (const worker of Object.values(cluster.workers)) {
  worker.send('big announcement to all workers');
}

Cluster (集群)#

工作原理#

类: Worker#

事件：'disconnect'#

事件：'error'#

事件: 'exit'#

事件：'listening'#

事件: 'message'#

事件: 'online'#

worker.disconnect()#

worker.exitedAfterDisconnect#

worker.id#

worker.isConnected()#

worker.isDead()#

worker.kill([signal])#

worker.process#

worker.send(message[, sendHandle[, options]][, callback])#

事件：'disconnect'#

事件：'exit'#

事件：'fork'#

事件：'listening'#

事件: 'message'#

事件：'online'#

事件：'setup'#

cluster.disconnect([callback])#

cluster.fork([env])#

cluster.isMaster#

cluster.isPrimary#

cluster.isWorker#

cluster.schedulingPolicy#

cluster.settings#

cluster.setupMaster([settings])#

cluster.setupPrimary([settings])#

cluster.worker#

cluster.workers#

类: `Worker`#

事件：`'disconnect'`#

事件：`'error'`#

事件: `'exit'`#

事件：`'listening'`#

事件: `'message'`#

事件: `'online'`#

`worker.disconnect()`#

`worker.exitedAfterDisconnect`#

`worker.id`#

`worker.isConnected()`#

`worker.isDead()`#

`worker.kill([signal])`#

`worker.process`#

`worker.send(message[, sendHandle[, options]][, callback])`#

事件：`'disconnect'`#

事件：`'exit'`#

事件：`'fork'`#

事件：`'listening'`#

事件: `'message'`#

事件：`'online'`#

事件：`'setup'`#

`cluster.disconnect([callback])`#

`cluster.fork([env])`#

`cluster.isMaster`#

`cluster.isPrimary`#

`cluster.isWorker`#

`cluster.schedulingPolicy`#

`cluster.settings`#

`cluster.setupMaster([settings])`#

`cluster.setupPrimary([settings])`#

`cluster.worker`#

`cluster.workers`#