(给前端大全加星标,提升前端技能)

作者:程序员成长指北公号 / koala (本文来自作者投稿)

前言

进程线程是一个程序员的必知概念,面试经常被问及,但是一些文章内容只是讲讲理论知识,可能一些小伙伴并没有真的理解,在实际开发中应用也比较少。本篇文章除了介绍概念,通过Node.js 的角度讲解 进程与 线程,并且讲解一些在项目中的实战的应用,让你不仅能迎战面试官还可以在实战中完美应用。

文章导览

windows主进程已停止工作_停止进程命令_进程停止运行

面试会问

Node.js是单线程吗?

Node.js 做耗时的计算时候,如何避免阻塞?

Node.js如何实现多进程的开启和关闭?

Node.js可以创建线程吗?

你们开发过程中如何实现进程守护的?

除了使用第三方模块,你们自己是否封装过一个多进程架构?

进程

进程 Process是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础,进程是线程的容器(来自百科)。进程是资源分配的最小单位。我们启动一个服务、运行一个实例,就是开一个服务进程,例如 Java 里的 JVM 本身就是一个进程,Node.js 里通过 node app.js 开启一个服务进程,多进程就是进程的复制(fork),fork 出来的每个进程都拥有自己的独立空间地址、数据栈,一个进程无法访问另外一个进程里定义的变量、数据结构,只有建立了 IPC 通信,进程之间才可数据共享。

  1. const http = require('http');


  2. const server = http.createServer();

  3. server.listen(3000,()=>{

  4. process.title='程序员成长指北测试进程';

  5. console.log('进程id',process.pid)

  6. })

运行上面代码后,以下为 Mac 系统自带的监控工具 “活动监视器” 所展示的效果,可以看到我们刚开启的 Nodejs 进程 7663

进程停止运行_停止进程命令_windows主进程已停止工作

线程

线程是操作系统能够进行运算调度的最小单位,首先我们要清楚线程是隶属于进程的,被包含于进程之中。一个线程只能隶属于一个进程,但是一个进程是可以拥有多个线程的。

单线程

单线程就是一个进程只开一个线程

Javascript 就是属于单线程,程序顺序执行(这里暂且不提JS异步),可以想象一下队列,前面一个执行完之后,后面才可以执行,当你在使用单线程语言编码时切勿有过多耗时的同步操作,否则线程会造成阻塞,导致后续响应无法处理。你如果采用 Javascript 进行编码时候,请尽可能的利用Javascript异步操作的特性。

经典计算耗时造成线程阻塞的例子

  1. const http = require('http');

  2. const longComputation = () => {

  3. let sum = 0;

  4. for(let i = 0; i < 1e10; i++) {

  5. sum += i;

  6. };

  7. return sum;

  8. };

  9. const server = http.createServer();

  10. server.on('request', (req, res) => {

  11. if(req.url === '/compute') {

  12. console.info('计算开始',newDate());

  13. const sum = longComputation();

  14. console.info('计算结束',newDate());

  15. return res.end(`Sum is ${sum}`);

  16. } else{

  17. res.end('Ok')

  18. }

  19. });


  20. server.listen(3000);

  21. //打印结果

  22. //计算开始 2019-07-28T07:08:49.849Z

  23. //计算结束 2019-07-28T07:09:04.522Z

查看打印结果,当我们调用 127.0.0.1:3000/compute的时候,如果想要调用其他的路由地址比如127.0.0.1/大约需要15秒时间,也可以说一个用户请求完第一个 compute接口后需要等待15秒,这对于用户来说是极其不友好的。下文我会通过创建多进程的方式 child_process.fork 和 cluster 来解决解决这个问题。

单线程的一些说明Node.js 中的进程与线程

Node.js 是 Javascript 在服务端的运行环境,构建在 chrome 的 V8 引擎之上,基于事件驱动、非阻塞I/O模型,充分利用操作系统提供的异步 I/O 进行多任务的执行,适合于 I/O 密集型的应用场景,因为异步,程序无需阻塞等待结果返回,而是基于回调通知的机制,原本同步模式等待的时间,则可以用来处理其它任务,

科普:在 Web 服务器方面,著名的 Nginx 也是采用此模式(事件驱动),避免了多线程的线程创建、线程上下文切换的开销,Nginx 采用 C 语言进行编写,主要用来做高性能的 Web 服务器,不适合做业务。

Web业务开发中,如果你有高并发应用场景那么 Node.js 会是你不错的选择。

在单核 CPU 系统之上我们采用 单进程 + 单线程 的模式来开发。在多核 CPU 系统之上,可以通过 child_process.fork 开启多个进程(Node.js 在 v0.8 版本之后新增了Cluster 来实现多进程架构) ,即 多进程 + 单线程 模式。注意:开启多进程不是为了解决高并发,主要是解决了单进程模式下 Node.js CPU 利用率不足的情况,充分利用多核 CPU 的性能。

Node.js 中的进程process 模块

Node.js 中的进程 Process 是一个全局对象,无需 require 直接使用,给我们提供了当前进程中的相关信息。官方文档提供了详细的说明,感兴趣的可以亲自实践下 Process 文档。

以上仅列举了部分常用到功能点,除了 Process 之外 Node.js 还提供了 child_process 模块用来对子进程进行操作,在下文 Nodejs进程创建会继续讲述。

Node.js 进程创建

进程创建有多种方式,本篇文章以child_process模块和cluster模块进行讲解。

child_process模块

child_process 是 Node.js 的内置模块,官网地址:

childprocess 官网地址:process.html#childprocesschild_process

几个常用函数:四种方式

CPU 核心数这里特别说明下,fork 确实可以开启多个进程,但是并不建议衍生出来太多的进程,cpu核心数的获取方式 constcpus=require(‘os’).cpus();,这里 cpus 返回一个对象数组,包含所安装的每个 CPU/内核的信息,二者总和的数组哦。假设主机装有两个cpu,每个cpu有4个核,那么总核数就是8。

fork开启子进程 Demo

fork开启子进程解决文章起初的计算耗时造成线程阻塞。在进行 compute 计算时创建子进程,子进程计算完成通过 send 方法将结果发送给主进程,主进程通过 message 监听到信息后处理并退出。

fork_app.js

  1. const http = require('http');

  2. const fork = require('child_process').fork;


  3. const server = http.createServer((req, res) => {

  4. if(req.url == '/compute'){

  5. const compute = fork('./fork_compute.js');

  6. compute.send('开启一个新的子进程');


  7. // 当一个子进程使用 process.send() 发送消息时会触发 'message' 事件

  8. compute.on('message', sum => {

  9. res.end(`Sum is ${sum}`);

  10. compute.kill();

  11. });


  12. // 子进程监听到一些错误消息退出

  13. compute.on('close', (code, signal) => {

  14. console.log(`收到close事件,子进程收到信号 ${signal} 而终止,退出码 ${code}`);

  15. compute.kill();

  16. })

  17. }else{

  18. res.end(`ok`);

  19. }

  20. });

  21. server.listen(3000, 127.0.0.1, () => {

  22. console.log(`server started at http://${127.0.0.1}:${3000}`);

  23. });

fork_compute.js

针对文初需要进行计算的的例子我们创建子进程拆分出来单独进行运算。

  1. const computation = () => {

  2. let sum = 0;

  3. console.info('计算开始');

  4. console.time('计算耗时');


  5. for(let i = 0; i < 1e10; i++) {

  6. sum += i

  7. };


  8. console.info('计算结束');

  9. console.timeEnd('计算耗时');

  10. return sum;

  11. };


  12. process.on('message', msg => {

  13. console.log(msg, 'process.pid', process.pid); // 子进程id

  14. const sum = computation();


  15. // 如果Node.js进程是通过进程间通信产生的,那么,process.send()方法可以用来给父进程发送消息

  16. process.send(sum);

  17. })

cluster模块

cluster 开启子进程Demo

  1. const http = require('http');

  2. const numCPUs = require('os').cpus().length;

  3. const cluster = require('cluster');

  4. if(cluster.isMaster){

  5. console.log('Master proces id is',process.pid);

  6. // fork workers

  7. for(let i= 0;i<numCPUs;i++){

  8. cluster.fork();

  9. }

  10. cluster.on('exit',function(worker,code,signal){

  11. console.log('worker process died,id',worker.process.pid)

  12. })

  13. }else{

  14. // Worker可以共享同一个TCP连接

  15. // 这里是一个http服务器

  16. http.createServer(function(req,res){

  17. res.writeHead(200);

  18. res.end('hello word');

  19. }).listen(8000);


  20. }

cluster原理分析

windows主进程已停止工作_进程停止运行_停止进程命令

cluster模块调用fork方法来创建子进程,该方法与child_process中的fork是同一个方法。cluster模块采用的是经典的主从模型,Cluster会创建一个master,然后根据你指定的数量复制出多个子进程,可以使用 cluster.isMaster属性判断当前进程是master还是worker(工作进程)。由master进程来管理所有的子进程,主进程不负责具体的任务处理,主要工作是负责调度和管理。

cluster模块使用内置的负载均衡来更好地处理线程之间的压力,该负载均衡使用了 Round-robin算法(也被称之为循环算法)。当使用Round-robin调度策略时,master accepts()所有传入的连接请求,然后将相应的TCP请求处理发送给选中的工作进程(该方式仍然通过IPC来进行通信)。

开启多进程时候端口疑问讲解:如果多个Node进程监听同一个端口时会出现 Error:listen EADDRIUNS的错误,而cluster模块为什么可以让多个子进程监听同一个端口呢?原因是master进程内部启动了一个TCP服务器,而真正监听端口的只有这个服务器,当来自前端的请求触发服务器的connection事件后,master会将对应的socket具柄发送给子进程。

child_process 模块与cluster 模块总结

无论是 child_process 模块还是 cluster 模块,为了解决 Node.js 实例单线程运行,无法利用多核 CPU 的问题而出现的。核心就是父进程(即 master 进程)负责监听端口,接收到新的请求后将其分发给下面的 worker 进程。

cluster模块的一个弊端:

进程停止运行_停止进程命令_windows主进程已停止工作

进程停止运行_停止进程命令_windows主进程已停止工作

cluster内部隐时的构建TCP服务器的方式来说对使用者确实简单和透明了很多,但是这种方式无法像使用childprocess那样灵活,因为一直主进程只能管理一组相同的工作进程,而自行通过childprocess来创建工作进程,一个主进程可以控制多组进程。原因是child_process操作子进程时,可以隐式的创建多个TCP服务器,对比上面的两幅图应该能理解我说的内容。

Node.js进程通信原理

前面讲解的无论是child_process模块,还是cluster模块,都需要主进程和工作进程之间的通信。通过fork()或者其他API,创建了子进程之后,为了实现父子进程之间的通信,父子进程之间才能通过message和send()传递信息。

IPC这个词我想大家并不陌生,不管那一张开发语言只要提到进程通信,都会提到它。IPC的全称是Inter-Process Communication,即进程间通信。它的目的是为了让不同的进程能够互相访问资源并进行协调工作。实现进程间通信的技术有很多,如命名管道,匿名管道,socket,信号量,共享内存,消息队列等。Node中实现IPC通道是依赖于libuv。windows下由命名管道(name pipe)实现,*nix系统则采用Unix Domain Socket实现。表现在应用层上的进程间通信只有简单的message事件和send()方法,接口十分简洁和消息化。

IPC创建和实现示意图

进程停止运行_windows主进程已停止工作_停止进程命令

IPC通信管道是如何创建的

停止进程命令_进程停止运行_windows主进程已停止工作

父进程在实际创建子进程之前,会创建 IPC通道并监听它,然后才 真正的创建出 子进程,这个过程中也会通过环境变量(NODECHANNELFD)告诉子进程这个IPC通道的文件描述符。子进程在启动的过程中,根据文件描述符去连接这个已存在的IPC通道,从而完成父子进程之间的连接。

Node.js句柄传递

讲句柄之前,先想一个问题,send句柄发送的时候,真的是将服务器对象发送给了子进程?

子进程对象send()方法可以发送的句柄类型send句柄发送原理分析

结合句柄的发送与还原示意图更容易理解。

进程停止运行_停止进程命令_windows主进程已停止工作

send()方法在将消息发送到IPC管道前,实际将消息组装成了两个对象,一个参数是hadler,另一个是message。message参数如下所示:

  1. {

  2. cmd:'NODE_HANDLE',

  3. type:'net.Server',

  4. msg:message

  5. }

发送到IPC管道中的实际上是我们要发送的句柄文件描述符。这个message对象在写入到IPC管道时,也会通过 JSON.stringfy()进行序列化。所以最终发送到IPC通道中的信息都是字符串,send()方法能发送消息和句柄并不意味着它能发送任何对象。

连接了IPC通道的子线程可以读取父进程发来的消息,将字符串通过JSON.parse()解析还原为对象后,才触发message事件将消息传递给应用层使用。在这个过程中,消息对象还要被进行过滤处理,message.cmd的值如果以NODE为前缀,它将响应一个内部事件internalMessage,如果message.cmd值为NODEHANDLE,它将取出 message.type值和得到的文件描述符一起还原出一个对应的对象。

以发送的TCP服务器句柄为例,子进程收到消息后的还原过程代码如下:

  1. function(message,handle,emit){

  2. var self = this;


  3. var server = new net.Server();

  4. server.listen(handler,function(){

  5. emit(server);

  6. });

  7. }

这段还原代码, 子进程根据message.type创建对应的TCP服务器对象,然后监听到文件描述符上。由于底层细节不被应用层感知,所以子进程中,开发者会有一种服务器对象就是从父进程中直接传递过来的错觉。

Node进程之间只有消息传递,不会真正的传递对象,这种错觉是抽象封装的结果。目前Node只支持我前面提到的几种句柄,并非任意类型的句柄都能在进程之间传递,除非它有完整的发送和还原的过程。

Node.js多进程架构模型

我们自己实现一个多进程架构守护Demo

进程停止运行_停止进程命令_windows主进程已停止工作

编写主进程

master.js 主要处理以下逻辑:

  1. // master.js

  2. const fork = require('child_process').fork;

  3. const cpus = require('os').cpus();


  4. const server = require('net').createServer();

  5. server.listen(3000);

  6. process.title = 'node-master'


  7. const workers = {};

  8. const createWorker = () => {

  9. const worker = fork('worker.js')

  10. worker.on('message', function(message) {

  11. if(message.act === 'suicide') {

  12. createWorker();

  13. }

  14. })

  15. worker.on('exit', function(code, signal) {

  16. console.log('worker process exited, code: %s signal: %s', code, signal);

  17. delete workers[worker.pid];

  18. });

  19. worker.send('server', server);

  20. workers[worker.pid] = worker;

  21. console.log('worker process created, pid: %s ppid: %s', worker.pid, process.pid);

  22. }


  23. for(let i=0; i<cpus.length; i++) {

  24. createWorker();

  25. }


  26. process.once('SIGINT', close.bind(this, 'SIGINT')); // kill(2) Ctrl-C

  27. process.once('SIGQUIT', close.bind(this, 'SIGQUIT')); // kill(3) Ctrl-

  28. process.once('SIGTERM', close.bind(this, 'SIGTERM')); // kill(15) default

  29. process.once('exit', close.bind(this));


  30. function close (code) {

  31. console.log('进程退出!', code);


  32. if(code !== 0) {

  33. for(let pid in workers) {

  34. console.log('master process exited, kill worker pid: ', pid);

  35. workers[pid].kill('SIGINT');

  36. }

  37. }


  38. process.exit(0);

  39. }

工作进程

worker.js 子进程处理逻辑如下:

  1. // worker.js

  2. const http = require('http');

  3. const server = http.createServer((req, res) => {

  4. res.writeHead(200, {

  5. 'Content-Type': 'text/plan'

  6. });

  7. res.end('I am worker, pid: '+ process.pid + ', ppid: '+ process.ppid);

  8. thrownewError('worker process exception!'); // 测试异常进程退出、重启

  9. });


  10. let worker;

  11. process.title = 'node-worker'

  12. process.on('message', function(message, sendHandle) {

  13. if(message === 'server') {

  14. worker = sendHandle;

  15. worker.on('connection', function(socket) {

  16. server.emit('connection', socket);

  17. });

  18. }

  19. });


  20. process.on('uncaughtException', function(err) {

  21. console.log(err);

  22. process.send({act: 'suicide'});

  23. worker.close(function() {

  24. process.exit(1);

  25. })

  26. })

Node.js 进程守护什么是进程守护?

每次启动 Node.js 程序都需要在命令窗口输入命令 node app.js 才能启动,但如果把命令窗口关闭则Node.js 程序服务就会立刻断掉。除此之外,当我们这个 Node.js 服务意外崩溃了就不能自动重启进程了。这些现象都不是我们想要看到的,所以需要通过某些方式来守护这个开启的进程,执行 node app.js 开启一个服务进程之后,我还可以在这个终端上做些别的事情,且不会相互影响。,当出现问题可以自动重启。

如何实现进程守护

这里我只说一些第三方的进程守护框架,pm2 和 forever ,它们都可以实现进程守护,底层也都是通过上面讲的 child_process 模块和 cluster 模块 实现的,这里就不再提它们的原理。

pm2 指定生产环境启动一个名为 test 的 node 服务

  1. pm2 start app.js --env production --name test

pm2常用api

pm2 官网地址:

forever 就不特殊说明了,官网地址

注意:二者更推荐pm2,看一下二者对比就知道我为什么更推荐使用pm2了。

linux 关闭一个进程

  1. root 201580.05.0125159295396? Sl5171:19 node /srv/mini-program-api/launch_pm2.js

  1. 上面是执行命令后在linux中显示的结果,第二个参数就是进程对应的PID

以优雅的方式结束进程

kill -l PID

-l选项告诉kill命令用好像启动进程的用户已注销的方式结束进程。当使用该选项时,kill命令也试图杀死所留下的子进程。但这个命令也不是总能成功–或许仍然需要先手工杀死子进程,然后再杀死父进程。

kill 命令用于终止进程

例如:kill-9[PID]-9 表示强迫进程立即停止

这个强大和危险的命令迫使进程在运行时突然终止,进程在结束后不能自我清理。危害是导致系统资源无法正常释放,一般不推荐使用,除非其他办法都无效。当使用此命令时,一定要通过ps -ef确认没有剩下任何僵尸进程。只能通过终止父进程来消除僵尸进程。如果僵尸进程被init收养,问题就比较严重了。杀死init进程意味着关闭系统。如果系统中有僵尸进程,并且其父进程是init,而且僵尸进程占用了大量的系统资源,那么就需要在某个时候重启机器以清除进程表了。

killall命令

杀死同一进程组内的所有进程。其允许指定要终止的进程的名称,而非PID。

限时特惠:本站每日持续更新海量各大内部网赚创业教程,会员可以下载全站资源点击查看详情
站长微信:11082411

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