node ( 5 ) -----process详解

进程

process 对象是一个全局变量，它提供当前 Node.js 进程的有关信息，以及控制当前 Node.js 进程。 因为是全局变量，所以无需使用 require()。在Node.js中每个应用程序都是一个进程类的实例对象。

进程对象属性

• execPath 可执行文件的绝对路径,如 /usr/local/bin/node
• version 版本号
• versions依赖库的版本号
• platform 运行平台。 如 darwin、freebsd、linux、sunos、win32
• stdin 标准输入流可读流，默认暂停状态
• stdout 标准输出可写流，同步操作
• argv 属性值为数组
• env 操作系统环境信息
• title 窗口标题
• arch 处理器架构 arm ia32 x64

process.stdin.resume();
process.stdin.on('data',function(chunk){
  process.stdout.write(`进程接收到数据: `+chunk);
});

process.argv.forEach((val,index,ary)=> console.log(index,val));

方法

1.memoryUsage 内存占用情况

process.memoryUsage()

• rss（resident set size）：所有内存占用，包括指令区和堆栈。
• heapTotal：”堆”占用的内存，包括用到的和没用到的。
• heapUsed：用到的堆的部分。
• external： V8 引擎内部的 C++ 对象占用的内存。

2.nextTick
nextTick方法用于将一个函数推迟到代码中所书写的下一个同步方法执行完毕或异步方法的回调函数开始执行前调用
3. chdir
chdir方法用于修改Node.js应用程序中使用的当前工作目录，使用方式如下

process.chdir(directory);

4.cwd
cwd方法用返回当前目录，不使用任何参数

console.log(process.cwd());

5.chdir
改变当前的工作目录

console.log(`当前目录: ${process.cwd()}`);
process.chdir('..);
console.log(`上层目录: ${process.cwd()});

6.exit
退出运行Node.js应用程序的进程

process.exit(0);

7.kill
- SIGINT 程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出，用于通知前台进程组终止进程。
- SIGTERM 程序结束(terminate)信号, 该信号可以被阻塞和处理。通常用来要求程序自己正常退出，shell命令kill缺省产生这个信号
- pid是一个整数，用于指定需要接收信号的进程ID
- signal 发送的信号，默认为 SIGTERM

process.kill(pid,[signal]);

8.uptime
返回当前程序的运行时间

process.uptime()

9.hrtime
测试一个代码段的运行时间,返回两个时间，第一个单位是秒，第二个单位是纳秒

let fs = require('fs);
let time = process.hrtime();
let data = fs.readFileSync('index.txt');
let diff = process.hrtime(time);
console.log(`读文件操作耗费的%d秒`,diff[0]);

10.exit

当运行Node.js应用程序进程退出时触发进程对象的exit事件。可以通过指定事件回调函数来指定进程退出时所执行的处理。(先退出，后关闭）

process.on('exit',function(){
    console.log('Node.js进程被推出);
});
process.exit();

11.uncaughtException
当应用程序抛出一个未被捕获的异常时触发进程对象的uncaughtException事件

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

12.信号事件

process.stdin.resume();
process.on('SIGINT',function(){
    console.log('接收到SIGINT信号');
});

子进程

• 在Node.js中，只有一个线程执行所有操作，如果某个操作需要大量消耗CPU资源的情况下，后续操作都需要等待。
• 在Node.js中，提供了一个child_process模块,通过它可以开启多个子进程，在多个子进程之间可以共享内存空间，可以通过子进程的互相通信来实现信息的交换。

spawn

child_process.spawn(command,[args],[options]);

• command 必须指定的参数，指定需要执行的命令
• args 数组，存放了所有运行该命令需要的参数
• options 参数为一个对象，用于指定开启子进程时使用的选项
  
  • cwd 子进程的工作目录
  • env 环境变量
  • detached 如果为true,该子进程魏一个进程组中的领头进程，当父进程不存在时也可以独立存在
  • stdio 三个元素的数组，设置标准输入/输出
    
    • pipe 在父进程和子进程之间创建一个管道，父进程可以通过子进程的stdio[0]访问子进程的标准输入，通过stdio[1]访问标准输出,stdio[2]访问错误输出
    • ipc 在父进程和子进程之间创建一个专用与传递消息的IPC通道。可以调用子进程的send方法向子进程发消息，子进程会触发message事件
    • ignore 指定不为子进程设置文件描述符。这样子进程的标准输入、标准输出和错误输出被忽略
    • stream 子进程和父进程共享一个终端设备、文件、端口或管道
    • 正整数值 和共享一个steam是一样的
    • null或undefined 在子进程中创建与父进程相连的管道
    • argv 代表的是子进程的参数，是个数组且第一，二项是固定的，（执行环境，执行文件）
      默认情况下，子进程的stdin,stdout,stderr导向了ChildProcess这个对象的child.stdin,child.stdout,child.stderr流,
      案例：
      spawn

let {spawn} = require('child_process');
let path = require('path');
// process.cwd()
let child = spawn('node',['1.test.js','a','b','c'],{
    cwd:path.join(__dirname,'pro')

});

//如果不写stdio 默认是管道类型
child.stdout.on('data',function(data){
    console.log(data.toString());
});

1.test.js

process.argv.slice(2).forEach(function(arg){
    process.stdout.write(arg);
})  

node 执行spawn文件,结果如下

a
bc
exit
close

detached
- 在默认情况下，只有在子进程全部退出后，父进程才能退出。为了让父进程可以先退出，而让子进程继续进行I/O操作,可以在spawn方法中使用options参数，把detached属性值设置为true
- 默认情况下父进程会等待所有的子进程退出后才可以退出，使用subprocess.unref方法可以让父进程不用等待子进程退出就可以直接退出
detached.js

// detach 将主进程关掉，子进程可以自己运行

// unref()

let {spawn} = require('child_process');
let path  = require('path');
let fd = require('fs').openSync('./100.txt','w')
let child = spawn('node',['detach.js'],{
    cwd:path.join(__dirname,'pro'),
    stdio:['ignore',fd,'ignore'],
    detached:true
});
child.unref();

detached.test.js

// 会自动将这个描述符包装成可写流
setInterval(function(){
    process.stdout.write('hello');
},1000);//最后只能在任务管理器中关了进程

ipc
用send和onmessage通信
ipc

let {spawn} = require('child_process');
let path = require('path');
let child = spawn('node',['3.ipc.js'],{
    cwd:path.join(__dirname,'pro'),
    stdio:['pipe','pipe','pipe','ipc']
})
// ignore 不要子进程的数据
// pipe 管道建立管道
// null
child.send({name:'李雷'});

child.on('message',function(data){
    console.log(data);//不会自动关闭，会一直跑着
    child.kill(); // 杀死进程
});

ipc.test.js

process.on('message',function(msg){
    process.send(msg.name+'很帅')
})

fork

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

child_process.fork(modulePath,[args],[options]);

• args 运行该文件模块文件时许哟啊使用的参数
• options 选项对象
  
  • cwd 指定子进程当前的工作目录
  • env 属性值为一个对象，用于以”键名/键值”的形式为子进程指定环境变量
  • encoding 属性值为一个字符串，用于指定输出及标准错误输出数据的编码格式，默认值为’utf8’
  • silent 属性值为布尔值，当属性值为false时，子进程和父进程对象共享标准(输入/输出),true时不共享

fork.js

let { spawn } = require('child_process');
let path = require('path');

let child = fork('fork.js', ['a', 'b', 'c'], {
    cwd: path.join(__dirname, 'pro'),
    silent: false // 这句话的意思就是 ['ignore','ignore','ignore','ipc']安静
});
// 默认支持ipc的方式
// 默认的fork [0,1,2,'ipc']
child.send('hello');

其实fork的实现很简单

function fork(modulePath, args, options = {}) {
    if (options.silent) {
        options.stdio = ['ignore', 'ignore', 'ignore', 'ipc']
    } else {
        options.stdio = [0, 1, 2, 'ipc']
    }
    return spawn('node', [modulePath, ...args],options)
}