Node.js入门之process模块、child_process模块、cluster模块

本文介绍: 本文主要介绍`node`中跟进程相关的三个模块。`process`是`node`的全局模块，作用比较直观。可以通过它来获得`node`进程相关的信息，`child _process`主要用来创建子进程，可以有效解决 node单线程效率不高的问题。`cluster`是`node`的集群模块，提供了开箱即用的进程创建功能。

本文主要介绍node中跟进程相关的三个模块。process是node的全局模块，作用比较直观。可以通过它来获得node进程相关的信息，child_process主要用来创建子进程，可以有效解决nod e单线程效率不高的问题。cluster是node的集群模块，提供了开箱即用的进程创建功能。

下面我们来看看process的一些常用的属性和方法。

process.env为node运行服务的环境变量。里面默认的变量很多，笔者就不一一列举了。

比如我们常用的NODE_ENV，我们执行NODE_ENV=production node process.js

console.log(process.env.NODE_ENV); // production

我们还可以传别的参数，比如我们执行aaa=dev node process.js

console.log(process.env.aaa); // dev

可以发现，通过key=value这种方式传递的参数就是环境变量。

process.argv用来获取命令行参数，会返回一个数组。它的第一第二个参数是固定的，分别是node可执行程序绝对路径和当前执行文件的绝对路径。后面的参数就是我们自己传传递的了。

比如我们执行node process.js name randy

console.log(process.argv);

注意，这种参数是没有=的。

process.execArgv用来获取特殊的参数。也就是运行node程序特有的参数啦，比如 --harmony。

我们来测试一下，执行node --harmony process.js name randy

console.log(process.execArgv); // [ '--harmony' ]

process.cwd() 返回当前工作路径

console.log(process.cwd()); // /Users/randy/myproject/base-learn/node

process.chdir(directory) 切换当前工作路径

process.chdir("../npm");
console.log(process.cwd()); // /Users/randy/myproject/base-learn/npm

process.config返回node的编译配置相关参数。这个配置的参数也有很多，笔者就不一一列举了。

console.log("process.config", process.config);

console.log(process.pid); // 19540

返回和设置当前进程的名称，当你用ps命令，同时有多个node进程在跑的时候，作用就出来了。

process.title = "主进程";
console.log(process.title); // 主进程

console.log(process.uptime()); // 0.0291715

console.log(process.memoryUsage());

console.log(process.version); // v14.21.1

返回node的版本，以及依赖库的版本

console.log(process.versions);

返回 node 可执行程序的绝对路径

console.log(process.execPath); // C:UserslqAppDataRoamingnvmv14.21.1node.exe

console.log(process.arch); // x64

console.log(process.platform); // win32

这个方法类似js里面的promise.then()，是node中的微任务。不过还是有细微差别，后面讲node事件循环的时候我们再细说。现在简单理解成微任务就行。

setTimeout(() =&gt; {
  console.log("setTimeout");
}, 0);

process.nextTick(() =&gt; {
  console.log("process.nextTick");
});

我们可以看到，就算定时器在前，并且延迟是0毫秒也会在process.nextTick后输出。

process.stdin、process.stdout、process.stderr 分别代表进程的标准输入、标准输出、标准错误输出。

process.stdin.setEncoding("utf8");
// 监听读取
process.stdin.on("readable", () =&gt; {
  var chunk = process.stdin.read();
  if (chunk !== null) {
    process.stdout.write(`data: ${chunk}`);
  }
});

// 读关闭
process.stdin.on("end", () =&gt; {
  process.stdout.write("stdin end");
});

执行程序，可以看到，程序通过 process.stdin 读取用户输入的同时，通过 process.stdout 将内容输出到控制台

hello
data: hello
world
data: world

我们知道，node 是单线程的，当有密集计算时就会出现性能瓶颈，child_process就是该性能瓶颈的一个解决方法。他能创建多个子进程分别处理，可以有效的提高程序的执行效率。

利用node提供的child_process模块，可以很容易的衍生出一个子进程，而且子进程之间可以通过事件消息系统进行互相通信。

node的child_process模块提供四种异步函数和三种同步函数的方式创建子进程：

spawn启动一个子进程，并执行命令。

下面我们举个简单的例子，创建一个子进程并执行ls -al命令。

const childProcess = require("child_process");
const ls = childProcess.spawn("ls", ["-al"]);

ls.stdout.on("data", function (data) {
  console.log("data from child: " + data);
});

// 错误
ls.stderr.on("data", function (data) {
  console.log("error from child: " + data);
});

ls.on("close", function (code) {
  console.log("child exists with code: " + code);
});

exec方法将会生成一个子shell，然后在该 shell 中执行命令，并缓冲产生的数据，当子流程完成后，并将子进程的输出以回调函数参数的形式一次性返回。exec方法会从子进程中返回一个完整的buffer。

默认情况下，这个buffer的大小应该是200k。如果子进程返回的数据大小超过了200k，程序将会崩溃，同时显示错误信息“Error：maxBuf fer exc eeded”。你可以通过在ex ec的可选项中设置一个更大的buffer体积来解决这个问题，但是你不应该这样做，因为ex ec本来就不是用来返回很多数据的方法。

下面我们举个简单的例子，创建一个子进程并执行ls -al命令。

const childProcess = require("child_process");

childProcess.exec("ls -al", {encoding: 'utf8'}, function (error, stdout, stderr) {
  if (error) {
    console.error("error: " + error);
    return;
  }
  console.log("stdout: " + stdout);
});

child_process.execFile() 函数与 child_process.exec()类似，不同之处在于它默认不衍生 sh ell。而是指定的可执行文件 file 直接作为新进程衍生，使其比 child_process.exec() 略有效率。

支持与 child_process.exec()相同的options。由于未衍生 sh ell，因此不支持 I/O 重定向和文件通配等行为。

下面我们举个简单的例子，创建一个子进程并执行node --version命令。

const childProcess = require("child_process");

childProcess.execFile("node", ["--version"], function (error, stdout, stderr) {
  if (error) {
    throw error;
  }
  console.log("execFile", stdout); // execFile v14.21.1
});

child_process.fork 是 spawn() 的特殊形式，用于在子进程中运行的模块，如 fork('./connectedChild.js') 相当于 spawn(‘node’, ['./connectedChild.js']) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

// connectedChild.js

// 监听主进程传递来的数据
process.on("message", (msg) => {
  console.log("Message from parent:", msg);
  // 如果当前进程是子进程，且与父进程之间通过IPC通道连接着，则process.connected为true
  console.log("process.connected: " + process.connected);
});

// 发送数据给主进程
setTimeout(() => {
  process.send({ name: "child message" });
  // 断开与父进程之间的IPC通道，此时会将 process.connected 置为false
  process.disconnect();
  console.log("process.connected: " + process.connected);
}, 1000);

主进程通过fork创建一个子进程执行connectedChild.js。

const childProcess = require("child_process");

const forked = childProcess.fork("./connectedChild.js");
// 发送数据给子进程
forked.send({ hello: "world" });
// 监听子进程发送来的数据
forked.on("message", (msg) => {
  console.log("Message from child", msg);
});

前面我们介绍了child_process模块，该模块主要用来创建子进程，产生多个子进程，这样就可以使用多核CPU，充分利用了服务器的资源。但是child_process模块需要我们手动创建子进程并管理。但是Node的 cluster 模块，提供了开箱即用的子进程创建功能，使用的好能大大提高我们系统的可用性和稳定性。接下来让我们去详细了解一下。

cluster 模块基于child_process模块的fork方法，多次fork主进程，产生多个子进程，这样就可以使用多核CPU，充分利用了服务器的资源。

在 cluster 模式中存在 master 和 worker 的概念，master 就是主进程，worker 则是子进程。master会通过fork产生多个worker，并管理他们。每一个worker代表着一个应用程序的实例。

// server.js
const cluster = require("cluster");
const http = require("http");

console.log(cluster.isMaster, process.pid);

if (cluster.isMaster) {
  for (var i = 0; i < 4; i++) {
    cluster.fork();
  }
} else {
  http
    .createServer(function (req, res) {
      res.end(`response from worker ${process.pid}`);
    })
    .listen(3000);

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

执行我们的server.js，如果是主程序就会创建子进程，如果是子进程就会创建http服务。

node ./server.js

创建批处理脚本：.req.sh。批量执行请求。

#!/bin/bash

# req.sh
for((i=1;i<=4;i++)); do   
  curl http://127.0.0.1:3000
  echo ""
done

response from worker 21256
response from worker 21256
response from worker 20612
response from worker 5964

说完了cluster的简单使用，接下来我们来讨论下面三个问题。

这个问题比较简单。master进程通过 cluster.fork() 来创建 worker 进程。cluster.fork() 内部是通过 child_process.fork() 来创建子进程。

秘密在于，net模块中，对 listen() 方法进行了特殊处理。根据当前进程是master进程，还是worker进程：

每当worker进程创建server实例来监听请求，都会通过IPC通道，在master上进行注册。当客户端请求到达，master会负责将请求转发给对应的worker。

具体转发给哪个worker？这是由转发策略决定的。可以通过环境变量NODE_CLUSTER_SCHED_POLICY设置，也可以在cluster.setupMaster(options)时传入。

// worker 子进程 server.js

setTimeout(() => {
  process.exit(1) 
}, Math.random()*10000);

//master 主进程 cluster.js
cluster.on("exit", (worker, code, signal) => {
  if (code !== 0 &amp;&amp; !worker.exitedAfterDisconnect) {
    console.log(`Worker ${worker.id} crashed.` + "Starting a new worker...");
    cluster.fork();
  }
});

如果使用了太多的服务器资源，master会根据需要通过disconnect方法杀死一些worker进程，这种情况下 worker.exitedAfterDisconnect值为tr ue，并不需要重新创建一个worker进程。

显示所有内容

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

简介

proc e ss

pro ce ss.env

pro c es s.ar g v

p ro c es s.execAr g v

pr ocess.cwd()

process.ch dir(directory)

process.config

process.pid

process.title

process.up time()

process.memoryUsage()

process.version

process.versions

process.execPa th

process.arch

process.plat form

process.nextTic k(fn)

process.std in、process.stdout、process.std err

child _process

spawn(command,[args],[options])

exec(command[, options][, callback])

execFile(file[, args][, options][, callback])

fork(modulePath[, args][, options])

总结

cluster

提高 服务器的可用性

1. master、worker如何通信

2. 如何 实现 端口 共享

3. 如何将请求分发到多个worker

提高 服务器的稳定性

系列 文章

后记

发表回复取消回复

process.env

process.argv

process.execArgv

process.cwd()

process.chdir(directory)

process.config

process.pid

process.title

process.uptime()

process.memoryUsage()

process.version

process.versions

process.execPath

process.arch

process.platform

process.nextTick(fn)

process.stdin、process.stdout、process.stderr

child_process