七天学会NodeJS（三）进程管理（util.format、Process、Child Process、Clu

愚人码头

七天教会NodeJS（三）历程办理（util.format、Process、Child Process、Cluster）、子历程女历程之间通信、同步编程、非常处置、域（Domain）


文章目次

• 七天教会NodeJS（三）历程办理（util.format、Process、Child Process、Cluster）、子历程女历程之间通信、同步编程、非常处置、域（Domain）
  
• 
  
  
  
  • 1. 历程办理
    
  • 
    
    
    
    • 开门白
      
    • API走马不雅花
      
    • 
      
      
      
      • Process
        
      • Child Process
        
      • Cluster
        
         
      
    • 使用场景
      
    • 
      
      
      
      • 怎样获得号令止参数
        
      • 怎样退出法式
        
      • 怎样掌握输进输出
        
      • 怎样降权
        
      • 怎样创立子历程
        
      • 历程间怎样通信
        
      • 怎样保护子历程
        
         
      
    • 小结
      
       
    
  • 2. 同步编程
    
  • 
    
    
    
    • 回调
      
    • 代码设想形式
      
    • 
      
      
      
      • 函数返回值
        
      • 遍历数组
        
      • 非常处置
        
         
      
    • 域（Domain）
      
    • 
      
      
      
      • 圈套
        
         
      
    • 小结
      
      
    
  
  

  总结：
   

1. 历程办理

NodeJS能够感知战掌握本身历程的运转情况战形态，也能够创立子历程并取其协同事情，那使得NodeJS能够把多个法式组开正在一同配合完成某项事情，并正在此中充任胶火战调理器的感化。本章除引见取之相干的NodeJS内乱置模块中，借会重面引见典范的利用场景。
开门白

我们曾经明白了NodeJS自带的fs模块比力根底，把一个目次里的一切文件战子目次皆拷贝到另外一个目次里需求写很多代码。别的我们也明白，末端下的cp号令比力好用，一条cp -r source/* target号令就可以弄定目次拷贝。那我们起首看看怎样利用NodeJS挪用末端号令去简化目次拷贝，示例代码以下：

1. /* parent.js  那是女历程*/
2. //女历程正在创立子历程,正在options.stdio字段中经由过程ipc开启了一条IPC通讲，以后就能够监听子历程工具的message变乱领受去自子历程的动静
3. var child = child_process.spawn('node', [ 'child.js' ], {
4.         stdio: [ 0, 1, 2, 'ipc' ]
5.     });
7. child.on('message', function (msg) {
8.     console.log(msg);
9. });
11. //经由过程.send办法给子历程收收动静
12. child.send({ hello: 'hello' });
14. /* child.js  那是子历程*/
15. //正在子历程那边，能够正在process工具上监听message变乱领受去自女历程的动静
16. process.on('message', function (msg) {
17.     msg.hello = msg.hello.toUpperCase();
18.     //并经由过程.send办法背女历程收收动静。
19.     process.send(msg);
20. });

复造代码

从以上代码中能够看到，子历程是同步运转的，经由过程回调函数返回施行成果。
API走马不雅花

我们先大抵看看NodeJS供给了哪些战历程办理有闭的API。那里其实不一一引见每一个API的利用办法，民圆文档曾经做得很好了。
Process

  民圆文档： http://nodejs.org/api/process.html

任何一个历程皆有启动历程时利用的号令止参数，有尺度输进尺度输出，有运转权限，有运转情况战运转形态。正在NodeJS中，能够经由过程process工具感知战掌握NodeJS本身历程的各个方面。别的需求留意的是，process没有是内乱置模块，而是一个齐局工具，因而正在任何处所皆能够间接利用。
Child Process

  民圆文档： http://nodejs.org/api/child_process.html

利用child_process模块能够创立战掌握子历程。该模块供给的API中最核心的是.spawn，其他API皆是针对特定利用场景对它的进一步启拆，算是一种语法糖。
Cluster

  民圆文档： http://nodejs.org/api/cluster.html

cluster模块是对child_process模块的进一步启拆，公用于处理单历程NodeJS Web效劳器没法充实操纵多核CPU的成绩。利用该模块能够简化多历程效劳器法式的开辟，让每一个核上运转一个事情历程，并同一经由过程主历程监听端心战分收恳求。
使用场景

战历程办理相干的API零丁引见起去比力单调，因而那里从一些典范的使用场景动身，别离引见一些主要API的利用办法。
怎样获得号令止参数

正在NodeJS中能够经由过程process.argv获得号令止参数。可是比力不测的是，node施行法式途径战主模块文件途径牢固占有了argv[0]战argv[1]两个地位，而第一个号令止参数从argv[2]开端。为了让argv利用起去愈加天然，能够根据以下方法处置。

1. document.getElementById('button').addEventListener('click', () => {
2.   //被面击
3. })

复造代码

怎样退出法式

凡是一个法式做完一切工作后便一般退出了，这时候法式的退出形态码为0。大概一个法式运转时发作了非常后便挂了，这时候法式的退出形态码没有即是0。假如我们正在代码中捕捉了某个非常，可是觉得法式不该该持续运转下来，需求立即退出，而且需求把退出形态码设置为指定命字，好比1，就能够根据以下方法：

1. function async(fn, callback) {
2.     // Code execution path breaks here.
3.     setTimeout(function ()　{
4.         try {
5.             callback(null, fn());
6.         } catch (err) {
7.             callback(err);
8.         }
9.     }, 0);
10. }
12. async(null, function (err, data) {
13.     if (err) {
14.         console.log('Error: %s', err.message);
15.     } else {
16.         // Do something.
17.     }
18. });
20. -- Console ------------------------------
21. Error: object is not a function

复造代码

怎样掌握输进输出

NodeJS法式的尺度输进流（stdin）、一个尺度输出流（stdout）、一个尺度毛病流（stderr）别离对应process.stdin、process.stdout战process.stderr，第一个是只读数据流，后边两个是只写数据流，对它们的操纵根据对数据流的操纵方法便可。比方，console.log能够根据以下方法完成。

1. function async(request, callback) {
2.     // Do something.
3.     asyncA(request, function (data) {
4.         // Do something
5.         asyncB(request, function (data) {
6.             // Do something
7.             asyncC(request, function (data) {
8.                 // Do something
9.                 callback(data);
10.             });
11.         });
12.     });
13. }
15. http.createServer(function (request, response) {
16.     var d = domain.create();
18.     d.on('error', function () {
19.         response.writeHead(500);
20.         response.end();
21.     });
23.     d.run(function () {
24.         async(request, function (data) {
25.             response.writeHead(200);
26.             response.end(data);
27.         });
28.     });
29. });

复造代码

怎样降权

正在Linux体系下，我们明白需求利用root权限才气监听1024以下端心。可是一旦完成端心监听后，持续让法式运转正在root权限下存正在宁静隐患，因而最好能把权限降下去。以下是如许一个例子。

1. var child_process = require('child_process');
2. var util = require('util');
4. function copy(source, target, callback) {
5.     child_process.exec(
6.         util.format('cp -r %s/* %s', source, target), callback);
7. }
9. copy('a', 'b', function (err) {
10.     // ...
11. });

复造代码

上例中有几面需求留意：

• 假如是经由过程sudo获得root权限的，运转法式的用户的UID战GID保留正在情况变量SUDO_UID战SUDO_GID里边。假如是经由过程chmod +s方法获得root权限的，运转法式的用户的UID战GID可间接经由过程process.getuid战process.getgid办法获得。
  
• process.setuid战process.setgid办法只承受number范例的参数。
  
• 降权时必需先降GID再降UID，不然挨次反过去的话便出权限变动法式的GID了。
  

怎样创立子历程

以下是一个创立NodeJS子历程的例子。

1. function main(argv) {
2.     // ...
3. }
5. main(process.argv.slice(2));

复造代码

上例中利用了.spawn(exec, args, options)办法，该办法撑持三个参数。第一个参数是施行文件途径，能够是施行文件的相对或尽对途径，也能够是按照PATH情况变量能找到的施行文件名。第两个参数中，数组中的每一个成员皆按挨次对应一个号令止参数。第三个参数可选，用于设置子历程的施行情况取举动。
别的，上例中固然经由过程子历程工具的.stdout战.stderr会见子历程的输出，但经由过程options.stdio字段的不同设置，能够将子历程的输进输出重定背到任何数据流上，大概让子历程同享女历程的尺度输进输出流，大概间接疏忽子历程的输进输出。
历程间怎样通信

正在Linux体系下，历程之间能够经由过程旌旗灯号相互通讯。以下是一个例子。

1. try {
2.     // ...
3. } catch (err) {
4.     // ...
5.     process.exit(1);
6. }

复造代码

正在上例中，女历程经由过程.kill办法背子历程收收SIGTERM旌旗灯号，子历程监听process工具的SIGTERM变乱呼应旌旗灯号。没有要被.kill办法的称号利诱了，该办法素质上是用去给历程收收旌旗灯号的，历程支到旌旗灯号后详细要做啥，完整与决于旌旗灯号的品种战历程本身的代码。
别的，假如女子历程皆是NodeJS历程，就能够经由过程IPC（历程间通信）单背传递数据。以下是一个例子。

1. function log() {
2.     process.stdout.write(
3.         util.format.apply(util, arguments) + '\n');
4. }

复造代码

能够看到，女历程正在创立子历程时，正在options.stdio字段中经由过程ipc开启了一条IPC通讲，以后就能够监听子历程工具的message变乱吸取去自子历程的动静，并经由过程.send办法给子历程收收动静。正在子历程那边，能够正在process工具上监听message变乱吸取去自女历程的动静，并经由过程.send办法背女历程收收动静。数据正在传递过程当中，会先正在收收端利用JSON.stringify办法序列化，再正在吸取端利用JSON.parse办法反序列化。
怎样保护子历程

保护历程普通用于监控事情历程的运转形态，正在事情历程没有一般退出时重启事情历程，保证事情历程没有中止运转。以下是一种完成方法。

1. http.createServer(callback).listen(80, function () {
2.     var env = process.env,
3.         uid = parseInt(env['SUDO_UID'] || process.getuid(), 10),
4.         gid = parseInt(env['SUDO_GID'] || process.getgid(), 10);
6.     process.setgid(gid);
7.     process.setuid(uid);
8. });

复造代码

能够看到，事情历程非一般退出时，保护历程立即重启事情历程。
小结

本章引见了利用NodeJS办理历程时需求的API和次要的使用场景，总结起去有以下几面：

• 利用process工具办理本身。
  
• 利用child_process模块创立战办理子历程。
  

2. 同步编程

NodeJS最年夜的卖面——变乱机造战同步IO，对开辟者并非通明的。开辟者需求按同步方法编写代码才用得上那个卖面，而那一面也遭到了一些NodeJS阻挡者的鞭挞。但不论如何，同步编程的确是NodeJS最年夜的特性，出有把握同步编程便不克不及道是实正教会了NodeJS。本章将引见取同步编程相干的各类常识。
回调

正在代码中，同步编程的间接表现便是回调。同步编程依托于回调去完成，但不克不及道利用了回调后法式便同步化了。我们起首能够看看以下代码。

1. var child = child_process.spawn('node', [ 'xxx.js' ]);
3. child.stdout.on('data', function (data) {
4.     console.log('stdout: ' + data);
5. });
7. child.stderr.on('data', function (data) {
8.     console.log('stderr: ' + data);
9. });
11. child.on('close', function (code) {
12.     console.log('child process exited with code ' + code);
13. });

复造代码

能够看到，以上代码中的回调函数仍旧先于后绝代码施行。JS自己是单线程运转的，不成能正在一段代码借已结束运转时来运转此外代码，因而也便没有存正在同步施行的观点。
可是，假如某个函数做的工作是创立一个体的线程或历程，并取JS主线程并止天做一些工作，并正在工作做完后告诉JS主线程，那状况又纷歧样了。我们接着看看以下代码。

1. /* parent.js */
2. var child = child_process.spawn('node', [ 'child.js' ]);
4. child.kill('SIGTERM');
6. /* child.js */
7. process.on('SIGTERM', function () {
8.     cleanUp();
9.     process.exit(0);
10. });

复造代码

此次能够看到，回调函数后于后绝代码施行了。好像上边所道，JS自己是单线程的，没法同步施行，因而我们能够以为setTimeout那类JS标准以外的由运转情况供给的特别函数做的工作是创立一个仄止线程后立即返回，让JS主历程能够接着施行后绝代码，并正在支到仄止历程的告诉后再施行回调函数。除setTimeout、setInterval那些常睹的，那类函数借包含NodeJS供给的诸如fs.readFile之类的同步API。
别的，我们仍旧回到JS是单线程运转的那个究竟上，那决议了JS正在施行完一段代码之前没法施行包含回调函数正在内乱的此外代码。也便是道，即便仄止线程完成事情了，告诉JS主线程施行回调函数了，回调函数也要等到JS主线程闲暇时才气开端施行。以下便是那么一个例子。

1. /* parent.js  那是女历程*/
2. //女历程正在创立子历程,正在options.stdio字段中经由过程ipc开启了一条IPC通讲，以后就能够监听子历程工具的message变乱领受去自子历程的动静
3. var child = child_process.spawn('node', [ 'child.js' ], {
4.         stdio: [ 0, 1, 2, 'ipc' ]
5.     });
7. child.on('message', function (msg) {
8.     console.log(msg);
9. });
11. //经由过程.send办法给子历程收收动静
12. child.send({ hello: 'hello' });
14. /* child.js  那是子历程*/
15. //正在子历程那边，能够正在process工具上监听message变乱领受去自女历程的动静
16. process.on('message', function (msg) {
17.     msg.hello = msg.hello.toUpperCase();
18.     //并经由过程.send办法背女历程收收动静。
19.     process.send(msg);
20. });

复造代码

能够看到，原来该当正在1秒后被挪用的回调函数由于JS主线程闲于运转别的代码，实践施行工夫被年夜幅提早。
代码设想形式

同步编程有很多独有的代码设想形式，为了完成一样的功用，利用同步方法战同步方法编写的代码会有很年夜差别。以下别离引见一些常睹的形式。
函数返回值

利用一个函数的输出做为另外一个函数的输进是很常睹的需供，正在同步方法下普通按以下方法编写代码：

1. /* daemon.js */
2. function spawn(mainModule) {
3.     var worker = child_process.spawn('node', [ mainModule ]);
5.     worker.on('exit', function (code) {
6.         if (code !== 0) {
7.             spawn(mainModule);
8.         }
9.     });
10. }
12. spawn('worker.js');

复造代码

而正在同步方法下，因为函数施行成果没有是经由过程返回值，而是经由过程回调函数传递，因而普通按以下方法编写代码：

1. function heavyCompute(n, callback) {
2.     var count = 0,
3.         i, j;
5.     for (i = n; i > 0; --i) {
6.         for (j = n; j > 0; --j) {
7.             count += 1;
8.         }
9.     }
11.     callback(count);
12. }
14. heavyCompute(10000, function (count) {
15.     console.log(count);
16. });
18. console.log('hello');
20. -- Console ------------------------------
21. 100000000
22. hello

复造代码

能够看到，这类方法便是一个回调函数套一个回调函多，套得太多了很简单写出>外形的代码。
遍历数组

正在遍历数组时，利用某个函数顺次对数据成员做一些处置也是常睹的需供。假如函数是同步施行的，普通便会写出以下代码：
[code]var len = arr.length,    i = 0;for (; i <span class="token operator">