Detailed explanation of the use of node's process and child

This time I will bring you a detailed explanation of the use of node's process and child_process modules. What are the precautions when using node's process and child_process modules. The following is a practical case. Let's take a look. .

Concept of process

In Node.js each application is an instance object of the process class.
Use the process object to represent the application. This is a global object through which you can obtain the properties of the Node.jsy application and the user and environment running the program. methods and events.

Several important attributes in the process

stdin standard input readable stream
stdout standard input writable stream
stderr standard error output stream
argv Terminal input parameter array
env Operating system environment information
pid application process id

stdin and stdout

process.stdin.on('data', (chunk) => {
 process.stdout.write('进程接收到数据' + chunk)
})

Copy after login

operation result

argv

console.log(process.env)

Copy after login

env: Enter export NODE_ENV=develop

console.log(process.env.NODE_ENV) //develop

Copy after login

in the mac terminal Process method

process.memoryUsage() View memory usage information
process.nextTick() Execute after the current eventloop is executed Callback function
process.chdir() The chdir method is used to modify the current working directory used in Node.js applications
process.cwd( ) The current working directory of the process
process.kill() Kill the process
process .uncaughtException() Triggers the uncaughtException event of the process object when the application throws an uncaught exception

say() //方法不存在
process.on('uncaughtException',function(err){
 console.log('捕获到一个未被处理的错误:',err);
});

Copy after login

child_process

Subprocess is the focus of today’s discussion. There are some things that I don’t quite understand. I hope I can communicate with you more

Child_process appears background

In Node.js, only one thread performs all operations. If an operation requires a large amount of CPU resources, subsequent operations will need to wait.

In Node.js, a child_process module is provided, through which multiple child processes can be started, memory space can be shared between multiple child processes, and information exchange can be achieved through mutual communication of child processes.

The child_process module gives node the ability to create child processes arbitrarily. The official node documentation gives four methods for the child_proces module. Mapping to the operating system actually creates child processes. But for developers only, the APIs of these methods are a little different

child_process.exec(command[, options][, callback]) Starts the
child process to execute the shell command. You can obtain the script shell execution result through the callback parameter

child_process.execfile(file[, args][, options][, callback])
Different from the exec type, it does not execute a shell command but an executable file

child_process.spawn(command[, args][, options]) only executes a shell command and does not need to obtain the execution results

child_process.fork(modulePath[, args][, options]) can use node
to execute the .js file, and there is no need to obtain the execution results. The child process coming out of fork must be a node process

spawn

Syntax: child_process.spawn(command, [args], [options])

command Parameters that must be specified, specify the command to be executed
args array, which stores all the parameters required to run the command
The options parameter is an object used to specify the options used when starting the child process

const { spawn } = require('child_process')
const path = require('path')
let child1 = spawn('node', ['test1.js', 'yanyongchao'], {
 stdio: ['pipe', 'pipe', 'pipe'], // 三个元素数组 下面会详解
 cwd: dirname, 子进程工作目录
 env: process.env, 环境变量
 detached: true // 如果为true，当父进程不存在时也可以独立存在
})

Copy after login

In fact, the above is easy to understand except for the sdtio array. Let’s analyze stdio

stdio

stdio是一个数组，用来设置标准输入，标准输出，错误输出。个人理解

pipe：父进程和子进程之间建立一个管道

主进程代码

const path = require('path')
const { spawn } = require('child_process')
let p = spawn('node', ['childs_t.js'], {
 cwd: path.join(dirname, 'childs'),
 stdio: ['pipe', 'pipe', process.stderr]
})
p.stdout.on('data', (data) => {
 console.log(data.toString())
}) 
// 这里用stdout原因： 子进程的数据流与常规理解的数据流方向相反，
// stdin：写入流，stdout、stderr：读取流。

Copy after login

子进程代码

process.stdout.write('asd')

Copy after login

如果在stdio中放一个流，process.stdout,process.stdin

主进程代码

const { spawn } = require('child_process')
const path = require('path')
// 如果放的是一个流，则意味着父进程和子进程共享一个流
const p = spawn('node', ['child_t.js'], {
 cwd: path.join(dirname, 'childs'),
 stdio: [process.stdin, process.stdout, process.stderr]
})

Copy after login

子进程代码

process.stdout.write('asd') //控制台会输出asd

Copy after login

ipc

主进程代码

const path = require('path')
const { spawn } = require('child_process')
let p = spawn('node', ['child_t.js'], {
 cwd: path.join(dirname, 'childs'),
 stdio: ['ipc', 'pipe', 'pipe']
})
p.on('message', (msg) => {
 console.log(msg)
})
p.send('hello chhild_process')

Copy after login

子进程代码

process.on('message', (msg) => {
 process.send('子进程' + msg)
})
// child.send(message,[sendHandle]);//在父进程中向子进程发送消息
// process.send(message,[sendHandle]);//在子进程中向主进程发送消息

Copy after login

detached模式

const { spawn } = require('child_process')
const fs = require('fs')
const path = require('path')
let out = fs.openSync(path.join(dirname, 'childs/msg.txt'), 'w', 0o666)
let p = spawn('node', ['test4.js'], {
 detached: true, //保证父进程结束，子进程仍然可以运行
 stdio: 'ignore',
 cwd: path.join(dirname, 'childs')
})
p.unref()
p.on('close', function() {
 console.log('子进程关闭')
})
p.on('exit', function() {
 console.log('子进程退出')
})
p.on('error', function(err) {
 console.log('子进程1开启失败' + err)
})

Copy after login

fork开启一个子进程

衍生一个新的 Node.js 进程，并通过建立一个 IPC 通讯通道来调用一个指定的模块，该通道允许父进程与子进程之间相互发送信息
fork方法返回一个隐式创建的代表子进程的ChildProcess对象
子进程的输入/输出操作执行完毕后，子进程不会自动退出，必须使用process.exit()方法显式退出

子进程代码

const { fork } = require('child_process')
const path = require('path')
let child = fork(path.join(dirname, 'childs/fork1.js'))
child.on('message', (data) => {
 console.log('父进程接收到消息' + data)
})
child.send('hello fork')
child.on('error', (err) => {
 console.error(err)
})

Copy after login

子进程代码

process.on('message', (m, setHandle) => {
 console.log('子进程接收到消息' + m)
 process.send(m) //sendHandle是一个 net.Socket 或 net.Server 对象
})

Copy after login

exec开启子进程

// exec同步执行一个shell命令
let { exec } = require('child_process')
let path = require('path')
// 用于使用shell执行命令, 同步方法
let p1 = exec('node exec.js a b c', {cwd: path.join(dirname, 'childs')}, function(err, stdout, stderr) {
 console.log(stdout)
})

Copy after login

execFile开启子进程

let { execFile } = require('child_process')
let path = require('path')
let p1 = execFile('node', ['exec.js', 'a', 'b', 'c'], {
 cwd: path.join(dirname, 'childs')
}, function(err, stdout, stderr) {
 console.log(stdout)
})

Copy after login

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

Detailed explanation of the use of node's process and child_process modules