深入理解Node.js 进程与线程(8000长文彻底搞懂)开发者社区

深入理解Node.js 进程与线程(8000长文彻底搞懂)

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

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

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}`);
});

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);
})

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);
}

{
    cmd:'NODE_HANDLE',
    type:'net.Server',
    msg:message
}

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

// 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
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);
})

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

root     20158  0.0  5.0 1251592 95396 ?       Sl   5月17   1:19 node /srv/mini-program-api/launch_pm2.js

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

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

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

process.env.UV_THREADPOOL_SIZE = 64

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);

深入理解Node.js 进程与线程(8000长文彻底搞懂)

深入理解Node.js 进程与线程(8000长文彻底搞懂)

前言

文章导览

面试会问

进程

线程

单线程

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

单线程的一些说明

Node.js 中的进程与线程

Node.js 中的进程

process 模块

Node.js 进程创建

child_process模块

fork开启子进程 Demo

cluster模块

cluster原理分析

child_process 模块与cluster 模块总结

Node.js进程通信原理

Node.js句柄传递

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

send句柄发送原理分析

Node.js多进程架构模型

Node.js 进程守护

什么是进程守护？

如何实现进程守护

linux 关闭一个进程

Node.js 线程

Node.js关于单线程的误区

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

Libuv

Node.js 线程创建