深刻理解Node.js 中的进程与线程

时间  2019-11-05
标签 深刻 理解 node.js node 进程 线程 栏目 Node.js 繁體版
原文   原文链接

前言

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

文章导览

做者简介：koala，专一完整的 Node.js 技术栈分享，从 JavaScript 到 Node.js,再到后端数据库，祝您成为优秀的高级 Node.js 工程师。【程序员成长指北】做者，Github 博客开源项目 github.com/koala-codin…html

面试会问

Node.js是单线程吗？前端

Node.js 作耗时的计算时候，如何避免阻塞？java

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

Node.js能够建立线程吗？linux

大家开发过程当中如何实现进程守护的？git

除了使用第三方模块，大家本身是否封装过一个多进程架构?程序员

进程

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

  • Node.js开启服务进程例子
const http = require('http');

const server = http.createServer();
server.listen(3000,()=>{
    process.title='程序员成长指北测试进程';
    console.log('进程id',process.pid)
})
复制代码

运行上面代码后，如下为 Mac 系统自带的监控工具 “活动监视器” 所展现的效果，能够看到咱们刚开启的 Nodejs 进程 7663面试

线程

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

单线程

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

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

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

const http = require('http');
const longComputation = () => {
  let sum = 0;
  for (let i = 0; i < 1e10; i++) {
    sum += i;
  };
  return sum;
};
const server = http.createServer();
server.on('request', (req, res) => {
  if (req.url === '/compute') {
    console.info('计算开始',new Date());
    const sum = longComputation();
    console.info('计算结束',new Date());
    return res.end(`Sum is ${sum}`);
  } else {
    res.end('Ok')
  }
});

server.listen(3000);
//打印结果
//计算开始 2019-07-28T07:08:49.849Z
//计算结束 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 虽然是单线程模型，可是其基于事件驱动、异步非阻塞模式，能够应用于高并发场景，避免了线程建立、线程之间上下文切换所产生的资源开销。
  • 当你的项目中须要有大量计算，CPU 耗时的操做时候，要注意考虑开启多进程来完成了。
  • Node.js 开发过程当中，错误会引发整个应用退出，应用的健壮性值得考验，尤为是错误的异常抛出，以及进程守护是必需要作的。
  • 单线程没法利用多核CPU，可是后来Node.js 提供的API以及一些第三方工具相应都获得了解决，文章后面都会讲到。

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.env：环境变量，例如经过 process.env.NODE_ENV 获取不一样环境项目配置信息
  • process.nextTick：这个在谈及 Event Loop 时常常为会提到
  • process.pid：获取当前进程id
  • process.ppid：当前进程对应的父进程
  • process.cwd()：获取当前进程工做目录，
  • process.platform：获取当前进程运行的操做系统平台
  • process.uptime()：当前进程已运行时间，例如：pm2 守护进程的 uptime 值
  • 进程事件：process.on(‘uncaughtException’, cb) 捕获异常信息、process.on(‘exit’, cb）进程推出监听
  • 三个标准流：process.stdout 标准输出、process.stdin 标准输入、process.stderr 标准错误输出
  • process.title 指定进程名称，有的时候须要给进程指定一个名称

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

Node.js 进程建立

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

child_process模块

child_process 是 Node.js 的内置模块，官网地址：

child_process 官网地址：nodejs.cn/api/child_p…

几个经常使用函数： 四种方式

  • child_process.spawn()：适用于返回大量数据，例如图像处理，二进制数据处理。
  • child_process.exec()：适用于小量数据，maxBuffer 默认值为 200 * 1024 超出这个默认值将会致使程序崩溃，数据量过大可采用 spawn。
  • child_process.execFile()：相似 child_process.exec()，区别是不能经过 shell 来执行，不支持像 I/O 重定向和文件查找这样的行为
  • child_process.fork()： 衍生新的进程，进程之间是相互独立的，每一个进程都有本身的 V8 实例、内存，系统资源是有限的，不建议衍生太多的子进程出来，通长根据系统** CPU 核心数**设置。

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

fork开启子进程 Demo

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

fork_app.js

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

const server = http.createServer((req, res) => {
    if(req.url == '/compute'){
        const compute = fork('./fork_compute.js');
        compute.send('开启一个新的子进程');

        // 当一个子进程使用 process.send() 发送消息时会触发 'message' 事件
        compute.on('message', sum => {
            res.end(`Sum is ${sum}`);
            compute.kill();
        });

        // 子进程监听到一些错误消息退出
        compute.on('close', (code, signal) => {
            console.log(`收到close事件，子进程收到信号 ${signal} 而终止，退出码 ${code}`);
            compute.kill();
        })
    }else{
        res.end(`ok`);
    }
});
server.listen(3000, 127.0.0.1, () => {
    console.log(`server started at http://${127.0.0.1}:${3000}`);
});
复制代码

fork_compute.js

针对文初须要进行计算的的例子咱们建立子进程拆分出来单独进行运算。

const computation = () => {
    let sum = 0;
    console.info('计算开始');
    console.time('计算耗时');

    for (let i = 0; i < 1e10; i++) {
        sum += i
    };

    console.info('计算结束');
    console.timeEnd('计算耗时');
    return sum;
};

process.on('message', msg => {
    console.log(msg, 'process.pid', process.pid); // 子进程id
    const sum = computation();

    // 若是Node.js进程是经过进程间通讯产生的，那么，process.send()方法能够用来给父进程发送消息
    process.send(sum);
})
复制代码
cluster模块

cluster 开启子进程Demo

const http = require('http');
const numCPUs = require('os').cpus().length;
const cluster = require('cluster');
if(cluster.isMaster){
    console.log('Master proces id is',process.pid);
    // fork workers
    for(let i= 0;i<numCPUs;i++){
        cluster.fork();
    }
    cluster.on('exit',function(worker,code,signal){
        console.log('worker process died,id',worker.process.pid)
    })
}else{
    // Worker能够共享同一个TCP链接
    // 这里是一个http服务器
    http.createServer(function(req,res){
        res.writeHead(200);
        res.end('hello word');
    }).listen(8000);

}
复制代码
cluster原理分析

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模块的一个弊端：

cluster内部隐时的构建TCP服务器的方式来讲对使用者确实简单和透明了不少，可是这种方式没法像使用child_process那样灵活，由于一直主进程只能管理一组相同的工做进程，而自行经过child_process来建立工做进程，一个主进程能够控制多组进程。缘由是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建立和实现示意图

IPC通讯管道是如何建立的

父进程在实际建立子进程以前，会建立 IPC通道并监听它，而后才 真正的建立出 子进程，这个过程当中也会经过环境变量（NODE_CHANNEL_FD）告诉子进程这个IPC通道的文件描述符。子进程在启动的过程当中，根据文件描述符去链接这个已存在的IPC通道，从而完成父子进程之间的链接。

Node.js句柄传递

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

子进程对象send()方法能够发送的句柄类型
  • net.Socket TCP套接字
  • net.Server TCP服务器，任意创建在TCP服务上的应用层服务均可以享受它带来的好处
  • net.Native C++层面的TCP套接字或IPC管道
  • dgram.Socket UDP套接字
  • dgram.Native C++层面的UDP套接字
send句柄发送原理分析

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

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

{
    cmd:'NODE_HANDLE',
    type:'net.Server',
    msg:message
}
复制代码

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

链接了IPC通道的子线程能够读取父进程发来的消息，将字符串经过JSON.parse()解析还原为对象后，才触发message事件将消息传递给应用层使用。在这个过程当中，消息对象还要被进行过滤处理，message.cmd的值若是以NODE_为前缀，它将响应一个内部事件internalMessage，若是message.cmd值为NODE_HANDLE,它将取出message.type值和获得的文件描述符一块儿还原出一个对应的对象。

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

function(message,handle,emit){
    var self = this;
    
    var server = new net.Server();
    server.listen(handler,function(){
      emit(server);
    });
}
复制代码

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

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

Node.js多进程架构模型

咱们本身实现一个多进程架构守护Demo

编写主进程

master.js 主要处理如下逻辑：

  • 建立一个 server 并监听 3000 端口。
  • 根据系统 cpus 开启多个子进程
  • 经过子进程对象的 send 方法发送消息到子进程进行通讯
  • 在主进程中监听了子进程的变化，若是是自杀信号从新启动一个工做进程。
  • 主进程在监听到退出消息的时候，先退出子进程在退出主进程
// master.js
const fork = require('child_process').fork;
const cpus = require('os').cpus();

const server = require('net').createServer();
server.listen(3000);
process.title = 'node-master'

const workers = {};
const createWorker = () => {
    const worker = fork('worker.js')
    worker.on('message', function (message) {
        if (message.act === 'suicide') {
            createWorker();
        }
    })
    worker.on('exit', function(code, signal) {
        console.log('worker process exited, code: %s signal: %s', code, signal);
        delete workers[worker.pid];
    });
    worker.send('server', server);
    workers[worker.pid] = worker;
    console.log('worker process created, pid: %s ppid: %s', worker.pid, process.pid);
}

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

process.once('SIGINT', close.bind(this, 'SIGINT')); // kill(2) Ctrl-C
process.once('SIGQUIT', close.bind(this, 'SIGQUIT')); // kill(3) Ctrl-\
process.once('SIGTERM', close.bind(this, 'SIGTERM')); // kill(15) default
process.once('exit', close.bind(this));

function close (code) {
    console.log('进程退出！', code);

    if (code !== 0) {
        for (let pid in workers) {
            console.log('master process exited, kill worker pid: ', pid);
            workers[pid].kill('SIGINT');
        }
    }

    process.exit(0);
}
复制代码

工做进程

worker.js 子进程处理逻辑以下：

  • 建立一个 server 对象，注意这里最开始并无监听 3000 端口
  • 经过 message 事件接收主进程 send 方法发送的消息
  • 监听 uncaughtException 事件，捕获未处理的异常，发送自杀信息由主进程重建进程，子进程在连接关闭以后退出
// worker.js
const http = require('http');
const server = http.createServer((req, res) => {
	res.writeHead(200, {
		'Content-Type': 'text/plan'
	});
	res.end('I am worker, pid: ' + process.pid + ', ppid: ' + process.ppid);
	throw new Error('worker process exception!'); // 测试异常进程退出、重启
});

let worker;
process.title = 'node-worker'
process.on('message', function (message, sendHandle) {
	if (message === 'server') {
		worker = sendHandle;
		worker.on('connection', function(socket) {
			server.emit('connection', socket);
		});
	}
});

process.on('uncaughtException', function (err) {
	console.log(err);
	process.send({act: 'suicide'});
	worker.close(function () {
		process.exit(1);
	})
})
复制代码

Node.js 进程守护

什么是进程守护？

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

如何实现进程守护

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

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

pm2 start app.js --env production --name test
复制代码

pm2经常使用api

  • pm2 stop Name/processID 中止某个服务，经过服务名称或者服务进程ID

  • pm2 delete Name/processID 删除某个服务，经过服务名称或者服务进程ID

  • pm2 logs [Name] 查看日志，若是添加服务名称，则指定查看某个服务的日志，不加则查看全部日志

  • pm2 start app.js -i 4 集群，-i 参数用来告诉PM2以cluster_mode的形式运行你的app（对应的叫fork_mode），后面的数字表示要启动的工做线程的数量。若是给定的数字为0，PM2则会根据你CPU核心的数量来生成对应的工做线程。注意通常在生产环境使用cluster_mode模式，测试或者本地环境通常使用fork模式，方便测试到错误。

  • pm2 reload Name pm2 restart Name 应用程序代码有更新，能够用重载来加载新代码，也能够用重启来完成,reload能够作到0秒宕机加载新的代码，restart则是从新启动，生产环境中多用reload来完成代码更新！

  • pm2 show Name 查看服务详情

  • pm2 list 查看pm2中全部项目

  • pm2 monit用monit能够打开实时监视器去查看资源占用状况

pm2 官网地址：

pm2.keymetrics.io/docs/usage/…

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

github.com/foreverjs/f…

注意：两者更推荐pm2，看一下两者对比就知道我为何更推荐使用pm2了。www.jianshu.com/p/fdc12d82b…

linux 关闭一个进程

  • 查找与进程相关的PID号

    ps aux | grep server
    说明:

root     20158  0.0  5.0 1251592 95396 ?       Sl   5月17   1:19 node /srv/mini-program-api/launch_pm2.js
复制代码
上面是执行命令后在linux中显示的结果，第二个参数就是进程对应的PID
复制代码
  • 杀死进程

  1. 以优雅的方式结束进程

    kill -l PID

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

  2. kill 命令用于终止进程

例如： `kill -9 [PID]`
复制代码

-9 表示强迫进程当即中止

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

  1. killall命令

    杀死同一进程组内的全部进程。其容许指定要终止的进程的名称，而非PID。

    killall httpd

Node.js 线程

Node.js关于单线程的误区

const http = require('http');

const server = http.createServer();
server.listen(3000,()=>{
    process.title='程序员成长指北测试进程';
    console.log('进程id',process.pid)
})
复制代码

仍然看本文第一段代码，建立了http服务，开启了一个进程，都说了Node.js是单线程，因此 Node 启动后线程数应该为 1，可是为何会开启7个线程呢？难道Javascript不是单线程不知道小伙伴们有没有这个疑问？

解释一下这个缘由：

Node 中最核心的是 v8 引擎，在 Node 启动后，会建立 v8 的实例，这个实例是多线程的。

  • 主线程：编译、执行代码。
  • 编译/优化线程：在主线程执行的时候，能够优化代码。
  • 分析器线程：记录分析代码运行时间，为 Crankshaft 优化代码执行提供依据。
  • 垃圾回收的几个线程。

因此你们常说的 Node 是单线程的指的是 JavaScript 的执行是单线程的(开发者编写的代码运行在单线程环境中)，但 Javascript 的宿主环境，不管是 Node 仍是浏览器都是多线程的由于libuv中有线程池的概念存在的，libuv会经过相似线程池的实现来模拟不一样操做系统的异步调用，这对开发者来讲是不可见的。

某些异步 IO 会占用额外的线程

仍是上面那个例子，咱们在定时器执行的同时，去读一个文件：

const fs = require('fs')
setInterval(() => {
    console.log(new Date().getTime())
}, 3000)

fs.readFile('./index.html', () => {})
复制代码

线程数量变成了 11 个，这是由于在 Node 中有一些 IO 操做（DNS，FS）和一些 CPU 密集计算（Zlib，Crypto）会启用 Node 的线程池，而线程池默认大小为 4，由于线程数变成了 11。 咱们能够手动更改线程池默认大小：

process.env.UV_THREADPOOL_SIZE = 64
复制代码

一行代码轻松把线程变成 71。

Libuv

Libuv 是一个跨平台的异步IO库，它结合了UNIX下的libev和Windows下的IOCP的特性，最先由Node的做者开发，专门为Node提供多平台下的异步IO支持。Libuv自己是由C++语言实现的，Node中的非苏塞IO以及事件循环的底层机制都是由libuv实现的。

libuv架构图

在Window环境下，libuv直接使用Windows的IOCP来实现异步IO。在非Windows环境下，libuv使用多线程来模拟异步IO。

注意下面我要说的话，Node的异步调用是由libuv来支持的，以上面的读取文件的例子，读文件实质的系统调用是由libuv来完成的，Node只是负责调用libuv的接口，等数据返回后再执行对应的回调方法。

Node.js 线程建立

直到 Node 10.5.0 的发布，官方才给出了一个实验性质的模块 worker_threads 给 Node 提供真正的多线程能力。

先看下简单的 demo：

const {
  isMainThread,
  parentPort,
  workerData,
  threadId,
  MessageChannel,
  MessagePort,
  Worker
} = require('worker_threads');

function mainThread() {
  for (let i = 0; i < 5; i++) {
    const worker = new Worker(__filename, { workerData: i });
    worker.on('exit', code => { console.log(`main: worker stopped with exit code ${code}`); });
    worker.on('message', msg => {
      console.log(`main: receive ${msg}`);
      worker.postMessage(msg + 1);
    });
  }
}

function workerThread() {
  console.log(`worker: workerDate ${workerData}`);
  parentPort.on('message', msg => {
    console.log(`worker: receive ${msg}`);
  }),
  parentPort.postMessage(workerData);
}

if (isMainThread) {
  mainThread();
} else {
  workerThread();
}
复制代码

上述代码在主线程中开启五个子线程，而且主线程向子线程发送简单的消息。

因为 worker_thread 目前仍然处于实验阶段，因此启动时须要增长 --experimental-worker flag，运行后观察活动监视器，开启了5个子线程

worker_thread 模块

worker_thread 核心代码（地址https://github.com/nodejs/node/blob/master/lib/worker_threads.js） worker_thread 模块中有 4 个对象和 2 个类，能够本身去看上面的源码。

  • isMainThread: 是不是主线程，源码中是经过 threadId === 0 进行判断的。
  • MessagePort: 用于线程之间的通讯，继承自 EventEmitter。
  • MessageChannel: 用于建立异步、双向通讯的通道实例。
  • threadId: 线程 ID。
  • Worker: 用于在主线程中建立子线程。第一个参数为 filename，表示子线程执行的入口。
  • parentPort: 在 worker 线程里是表示父进程的 MessagePort 类型的对象，在主线程里为 null
  • workerData: 用于在主进程中向子进程传递数据（data 副本）

总结

多进程 vs 多线程

对比一下多线程与多进程：

属性 多进程 多线程 比较
数据 数据共享复杂，须要用IPC；数据是分开的，同步简单 由于共享进程数据，数据共享简单，同步复杂 各有千秋
CPU、内存 占用内存多，切换复杂，CPU利用率低 占用内存少，切换简单，CPU利用率高 多线程更好
销毁、切换 建立销毁、切换复杂，速度慢 建立销毁、切换简单，速度很快 多线程更好
coding 编码简单、调试方便 编码、调试复杂 编码、调试复杂
可靠性 进程独立运行，不会相互影响 线程同呼吸共命运 多进程更好
分布式 可用于多机多核分布式，易于扩展 只能用于多核分布式 多进程更好

参考文章：

加入咱们一块儿学习吧！

node学习交流群
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程