Worker类

‘online’ 事件

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

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

它不是在工作进程上触发的。

‘listening’ 事件

  • address {Object}

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

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

它不是在工作进程上触发的。

‘message’ 事件

  • message {Object}

类似于 cluster.on('message') 事件，但指定为该工作进程。

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

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

作为示例，有一个集群在主进程中使用消息系统保持对请求数量的计数：

  1. const cluster = require('cluster');
  2. const http = require('http');
  4. if (cluster.isMaster) {
  6.     // Keep track of http requests
  7.     var numReqs = 0;
  8.     setInterval(() => {
  9.         console.log('numReqs =', numReqs);
  10.     }, 1000);
  12.     // Count requests
  13.     function messageHandler(msg) {
  14.         if (msg.cmd && msg.cmd == 'notifyRequest') {
  15.             numReqs += 1;
  16.         }
  17.     }
  19.     // Start workers and listen for messages containing notifyRequest
  20.     const numCPUs = require('os').cpus().length;
  21.     for (var i = 0; i < numCPUs; i++) {
  22.         cluster.fork();
  23.     }
  25.     Object.keys(cluster.workers).forEach((id) => {
  26.         cluster.workers[id].on('message', messageHandler);
  27.     });
  29. } else {
  31.     // Worker processes have a http server.
  32.     http.Server((req, res) => {
  33.         res.writeHead(200);
  34.         res.end('hello world\n');
  36.         // notify master about the request
  37.         process.send({
  38.             cmd: 'notifyRequest'
  39.         });
  40.     }).listen(8000);
  41. }

‘disconnect’ 事件

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

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

‘exit’ 事件

  • code {Number} 在正常退出时的退出码。

  • signal {String} 导致进程被杀死的信号名称（如，'SIGHUP'）。

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

  1. const worker = cluster.fork();
  2. worker.on('exit', (code, signal) => {
  3.     if (signal) {
  4.         console.log(`worker was killed by signal: ${signal}`);
  5.     } else if (code !== 0) {
  6.         console.log(`worker exited with error code: ${code}`);
  7.     } else {
  8.         console.log('worker success!');
  9.     }
  10. });

‘error’ 事件

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

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

worker.id

  • {Number}

每个新的工作进程都被赋予它自己唯一的 ID，这个 ID 存储在 id 上。

工作进程还活着时，这个就是它在 cluster.workers 中的索引键值。

worker.process

  • {ChildProcess}

所有的工作进程都是通过 child_process.fork() 创建的，从该函数返回的对象被存储为 .process。在工作进程中，全局的 process 被存储。

详见：子进程模块。

请注意，如果 'disconnect' 事件发生在 process 上，并且 .suicide 不是 true，则工作进程会调用 process.exit(0)。这可以防止意外断开。

worker.suicide

  • {Boolean}

通过调用 .kill() 或 .disconnect() 设置，直到那时变成 undefined。

worker.suicide 的布尔值可以让你区分自行退出和意外退出，主进程可以选择不重新衍生基于该值的工作进程。

  1. cluster.on('exit', (worker, code, signal) => {
  2.     if (worker.suicide === true) {
  3.         console.log('Oh, it was just suicide\' – no need to worry').
  4.     }
  5. });
  7. // kill worker
  8. worker.kill();

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

  • message {Object}

  • sendHandle {Handle}

  • callback {Function}

  • 返回：Boolean

发送一个消息到一个工作进程或主进程，处理句柄是可选的。

在主进程中，它发送一个消息到一个指定工作进程上。它与 ChildProcess.send() 相同。

在工作进程中，它发送消息到主进程。它与 process.send() 相同。

这个例子会回复所有来自主进程的消息：

  1. if (cluster.isMaster) {
  2.     var worker = cluster.fork();
  3.     worker.send('hi there');
  5. } else if (cluster.isWorker) {
  6.     process.on('message', (msg) => {
  7.         process.send(msg);
  8.     });
  9. }

worker.disconnect()

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

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

使得 .suicide 被设置。

注意，一个服务器被关闭后，它将不再接受新的连接，但连接可能会被其他任何正在监听的工作进程所接收。现有的连接将被允许正常关闭。当不存在连接时，详见 server.close()，到工作进程的 IPC 通道会被关闭，且允许其优雅地死去。

以上仅适用于服务器的连接，客户端连接不会通过工作进程自动关闭，并且断开不会等到他们退出之前才关闭。

请注意，在一个工作进程中，存在 process.disconnect，但它不是这个函数，它是 disconnect。

因为长期活着的服务器连接可能会阻止工作进程断开，可能对它发送一个消息会很有用，所以应用指定动作可用于关闭它们。它同样对实现超时有用，如果在一段时间后没有触发 'disconnect' 事件，杀死该工作进程。

  1. if (cluster.isMaster) {
  2.     var worker = cluster.fork();
  3.     var timeout;
  5.     worker.on('listening', (address) => {
  6.         worker.send('shutdown');
  7.         worker.disconnect();
  8.         timeout = setTimeout(() => {
  9.             worker.kill();
  10.         }, 2000);
  11.     });
  13.     worker.on('disconnect', () => {
  14.         clearTimeout(timeout);
  15.     });
  17. } else if (cluster.isWorker) {
  18.     const net = require('net');
  19.     var server = net.createServer((socket) => {
  20.         // connections never end
  21.     });
  23.     server.listen(8000);
  25.     process.on('message', (msg) => {
  26.         if (msg === 'shutdown') {
  27.             // initiate graceful close of any connections to server
  28.         }
  29.     });
  30. }

worker.kill([signal=’SIGTERM’])

  • signal {String} 发送给工作进程的 kill 信号名称。

该函数会杀死工作进程。在主进程中，它通过断开 worker.process 做到这一点，并且一旦断开，使用 signal 杀死进程。在工作进程中，它通过断开信道做到这一点，并在那时使用代码 0 退出。

使得 .suicide 被设置。

该方法为了向下兼容作为 worker.destroy() 的别名。

请注意，在工作进程中，存在 process.kill()，但它不是这个函数，它是 kill。

worker.isConnected()

如果工作进程通过它的 IPC 通道连接到了它的主进程，那么这个函数返回 true，否则 false。一个工作进程在被创建后连接到它的主进程。它在触发 'disconnect' 事件后断开。

worker.isDead()

如果工作进程已终止（无论是正常退出还是被信号关闭），这个函数返回 true，否则它返回 false。