整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
提：
安裝配置有node環境
一、初始化node項目
在項目的工作目錄，執行命令
npm init
初始化參數設置，可以根據情況設置，或者直接全部默認也行：
初始化項目
二、安裝express模塊
Express是目前最流行的基于Node.js的Web開發框架，可以快速地搭建一個完整功能的網站。
直接通過命令行安裝
npm i express --save
G:\app-server>npm i -g express --save
+ express@4.17.1
added 2 packages from 2 contributors and updated 24 packages in 23.892s
三、編寫app.js
新建一個app.js文件
var express = require('express');
var app = express();
app.use(express.static(__dirname + '/public'));
app.listen(8080, () => {
console.log(`App listening at port 8080`)
})
在express添加中間件，設置靜態資源路徑為public，所有的HTML、CSS、JS等文件都放在public下即可。默認訪問public下面的index.html
新建index.html
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Web測試平臺</title>
</head>
<body>
<h1>Web測試平臺</h1>
</body>
</html>
四、啟動服務
node app.js
即可運行
G:\app-server>node app.js
App listening at port 8080
訪問ip:8080
就可以訪問到index.html那個頁面了哦。
好了，各位老鐵。相信你一定也學會搭建這個服務器環境了哦。
有問題歡迎留言哦。一起學習。
人這篇文章寫的確實很好，而且很詳細，圖文結合，也比較好理解，所以分享給大伙。
文章轉載自：https://mp.weixin.qq.com/s/fkrHHMwx75NLhvv4P3rk-w
進程與線程是一個程序員的必知概念，面試經常被問及，但是一些文章內容只是講講理論知識，可能一些小伙伴并沒有真的理解，在實際開發中應用也比較少。本篇文章除了介紹概念，通過Node.js 的角度講解 進程與 線程，并且講解一些在項目中的實戰的應用，讓你不僅能迎戰面試官還可以在實戰中完美應用。
進程 Process是計算機中的程序關于某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎，進程是線程的容器（來自百科）。進程是資源分配的最小單位。我們啟動一個服務、運行一個實例，就是開一個服務進程，例如 Java 里的 JVM 本身就是一個進程，Node.js 里通過 node app.js 開啟一個服務進程，多進程就是進程的復制（fork），fork 出來的每個進程都擁有自己的獨立空間地址、數據棧，一個進程無法訪問另外一個進程里定義的變量、數據結構，只有建立了 IPC 通信，進程之間才可數據共享。
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 是 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 的性能。
process 模塊
Node.js 中的進程 Process 是一個全局對象，無需 require 直接使用，給我們提供了當前進程中的相關信息。官方文檔提供了詳細的說明，感興趣的可以親自實踐下 Process 文檔。
以上僅列舉了部分常用到功能點，除了 Process 之外 Node.js 還提供了 child_process 模塊用來對子進程進行操作，在下文 Nodejs進程創建會繼續講述。
進程創建有多種方式，本篇文章以child_process模塊和cluster模塊進行講解。
child_process模塊
child_process 是 Node.js 的內置模塊，官網地址：
childprocess 官網地址：http://nodejs.cn/api/childprocess.html#childprocesschild_process
幾個常用函數：四種方式
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 = > {
// 子進程id
console.log(msg, 'process.pid', process.pid);
const sum = computation();
// 如果Node.js進程是通過進程間通信產生的，那么，process.send()方法可以用來給父進程發送消息
process.send(sum);
})
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 模塊，為了解決 Node.js 實例單線程運行，無法利用多核 CPU 的問題而出現的。核心就是父進程（即 master 進程）負責監聽端口，接收到新的請求后將其分發給下面的 worker 進程。
cluster模塊的一個弊端：
cluster內部隱式的構建TCP服務器的方式來說對使用者確實簡單和透明了很多，但是這種方式無法像使用childprocess那樣靈活，因為一個主進程只能管理一組相同的工作進程，而自行通過childprocess來創建工作進程，一個主進程可以控制多組進程。原因是child_process操作子進程時，可以隱式的創建多個TCP服務器，對比上面的兩幅圖應該能理解我說的內容。
前面講解的無論是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通道并監聽它，然后才 真正的創建出 子進程，這個過程中也會通過環境變量（NODECHANNELFD）告訴子進程這個IPC通道的文件描述符。子進程在啟動的過程中，根據文件描述符去連接這個已存在的IPC通道，從而完成父子進程之間的連接。
講句柄之前，先想一個問題，send句柄發送的時候，真的是將服務器對象發送給了子進程？
子進程對象send()方法可以發送的句柄類型
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值為NODEHANDLE,它將取出 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只支持我前面提到的幾種句柄，并非任意類型的句柄都能在進程之間傳遞，除非它有完整的發送和還原的過程。
我們自己實現一個多進程架構守護Demo
編寫主進程
master.js 主要處理以下邏輯：
// 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 子進程處理邏輯如下：
// 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 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 官網地址：
http://pm2.keymetrics.io/docs/usage/quick-start/
forever 就不特殊說明了，官網地址
https://github.com/foreverjs/forever
注意：二者更推薦pm2，看一下二者對比就知道我為什么更推薦使用pm2了。https://www.jianshu.com/p/fdc12d82b661
查找與進程相關的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
殺死進程
以優雅的方式結束進程
kill -l PID
-l選項告訴kill命令用好像啟動進程的用戶已注銷的方式結束進程。當使用該選項時，kill命令也試圖殺死所留下的子進程。但這個命令也不是總能成功--或許仍然需要先手工殺死子進程，然后再殺死父進程。
kill 命令用于終止進程
例如：kill-9[PID]-9 表示強迫進程立即停止
這個強大和危險的命令迫使進程在運行時突然終止，進程在結束后不能自我清理。危害是導致系統資源無法正常釋放，一般不推薦使用，除非其他辦法都無效。當使用此命令時，一定要通過ps -ef確認沒有剩下任何僵尸進程。只能通過終止父進程來消除僵尸進程。如果僵尸進程被init收養，問題就比較嚴重了。殺死init進程意味著關閉系統。如果系統中有僵尸進程，并且其父進程是init，
而且僵尸進程占用了大量的系統資源，那么就需要在某個時候重啟機器以清除進程表了。
killall命令
殺死同一進程組內的所有進程。其允許指定要終止的進程的名稱，而非PID。
killall httpd
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 的實例，這個實例是多線程的。
所以大家常說的 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 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 模塊
workerthread 核心代碼（地址https://github.com/nodejs/node/blob/master/lib/workerthreads.js）
worker_thread 模塊中有 4 個對象和 2 個類，可以自己去看上面的源碼。
多進程 vs 多線程
對比一下多線程與多進程：
于如何管理多個NodeJS版本，很早之前就寫過用nvm來管理的相關文章，這里就不贅述了，有需要的可以看這篇Node.js環境搭建：https://www.didispace.com/installation-guide/dev-env/nvm-nodejs.html
雖然有了多版本管理，但是默認版本只有一個，所以很多時候，在用VSCode打開不同項目的時候，還需要用nvm use來切換不同的版本使用。顯然一直這樣操作很麻煩，而且容易忘記什么項目用什么版本。
所以，最好就是能打開項目的時候，自動就切換到對應的NodeJS版本。
要實現這樣的效果只需要下面兩步：
第一步：安裝VSCode插件vsc-nvm
第二步：在項目根目錄下創建文件.nvmrc，文件內容為版本號，比如：
v10.13.0
完成配置后，關閉VSCode，再重新打開，可以看到終端自動打開，并執行了nvm use命令，實現了NodeJS版本的自動切換
我們正在連載開發者安裝大全（https://www.didispace.com/installation-guide/），主要整理與匯總開發者常用軟件、編程環境、中間件等工具的安裝使用方法，以指導開發者快速搭建自己需要的開發環境，歡迎關注、收藏、轉發支持一下啊 ^_^
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
