淺析 Node.js 單線程模型

總結筆記：對於每一個用戶請求，由主線程接收並存放於一個事件隊列中（不作任何處理），當無請求發生時，即主線程空閒，主線程開始循環處理事件隊列中的任務：

 

對於非阻塞JS程序：

一、若某事件須要I/O操做，則主線程發出I/O請求，而後繼續執行，由底層的程序實現I/O並返回I/O數據（底層程序是多線程的，JS是單線程的），底層I/O線程處理完後將該事件從新放入事件隊列並釋放當前線程；

二、某事件不須要I/O操做，則主線程直接處理；（由其餘線程處理後放入的事件此時也被主線程直接處理掉）；

 

對於阻塞JS程序：

一、若某事件須要I/O操做，則主線程發出I/O請求，而後等待I/O結束，由底層的程序實現I/O並返回I/O數據，主線程得到該事件所需數據後繼續處理該事件；

二、某事件不須要I/O操做，則主線程直接處理；

 

綜上可知，node.js由js解釋程序和底層代碼實現，JS代碼是主線程，是單線程執行，而底層代碼是多線程，可同時處理多個I/O請求，js中的阻塞與非阻塞代碼只決定js在I/O時繼不繼續執行（固然，若阻塞執行，底層多線程也沒啥用了），而底層會爲每個I/O請求建立一個線程；

 

注意：這只是對Node.js的一個分析，用來理解nodejs的線程模型而已，實際使用要具體問題具體分析，建議結合http://www.runoob.com/nodejs/nodejs-callback.html中的阻塞與非阻塞來學習，阻塞即只要一個主線程執行全部操做，當事件須要I/O操做則主線程等待I/O完成再繼續執行，而非阻塞，即對事件處理使用了事件回調，此時，主線程將繼續執行下一步的代碼而不用等待該事件I/O完成，當I/O完成時主線程再針對該事件執行相應的回調函數；

例如：一、

 

var http = require('http'); http.createServer(function (request, response) {     // 發送 HTTP 頭部      // HTTP 狀態值: 200 : OK     // 內容類型: text/plain     response.writeHead(200, {'Content-Type': 'text/plain'});     // 發送響應數據 "Hello World"     response.end('Hello World\n'); }).listen(8888); // 終端打印以下信息 console.log('Server running at http://127.0.0.1:8888/');

該主線程只作三件事：一、偵聽8888端口（偵聽操做也能夠理解爲是I/O操做，於是應當也是由底層程序實現，即底層程序監聽端口，如有事件，則放入事件隊列，繼續偵聽端口）； 二、JS主線程處理並生成返回數據； 三、返回處理結果（此步驟是I/O操做，由線程池處理）；

 

二、

 

var fs = require("fs"); fs.readFile('input.txt', function (err, data) { if (err) return console.error(err); console.log(data.toString()); }); console.log("程序執行結束!");

該主線程在執行I/O時不等待I/O完成，直接繼續執行，線程池線程執行完後將結果返還給主線程，主線程執行回調函數並處理事件；

 

 

正文

 

Node.js 採用事件驅動和異步 I/O 的方式，實現了一個單線程、高併發的 JavaScript 運行時環境，而單線程就意味着同一時間只能作一件事，那麼 Node.js 如何經過單線程來實現高併發和異步 I/O？本文將圍繞這個問題來探討 Node.js 的單線程模型 。

一、高併發策略

通常來講，高併發的解決方案就是提供多線程模型，服務器爲每一個客戶端請求分配一個線程，使用同步 I/O，系統經過線程切換來彌補同步 I/O 調用的時間開銷。好比 Apache 就是這種策略，因爲 I/O 通常都是耗時操做，所以這種策略很難實現高性能，但很是簡單，能夠實現複雜的交互邏輯。

而事實上，大多數網站的服務器端都不會作太多的計算，它們接收到請求之後，把請求交給其它服務來處理（好比讀取數據庫），而後等着結果返回，最後再把結果發給客戶端。所以，Node.js 針對這一事實採用了單線程模型來處理，它不會爲每一個接入請求分配一個線程，而是用一個主線程處理全部的請求，而後對 I/O 操做進行異步處理，避開了建立、銷燬線程以及在線程間切換所需的開銷和複雜性。

二、事件循環

Node.js 在主線程裏維護了一個事件隊列，當接到請求後，就將該請求做爲一個事件放入這個隊列中，而後繼續接收其餘請求。當主線程空閒時(沒有請求接入時)，就開始循環事件隊列，檢查隊列中是否有要處理的事件，這時要分兩種狀況：若是是非 I/O 任務，就親自處理，並經過回調函數返回到上層調用；若是是 I/O 任務，就從 線程池 中拿出一個線程來處理這個事件，並指定回調函數，而後繼續循環隊列中的其餘事件。

當線程中的 I/O 任務完成之後，就執行指定的回調函數，並把這個完成的事件放到事件隊列的尾部，等待事件循環，當主線程再次循環到該事件時，就直接處理並返回給上層調用。 這個過程就叫 事件循環 (Event Loop)，其運行原理以下圖所示：

這個圖是整個 Node.js 的運行原理，從左到右，從上到下，Node.js 被分爲了四層，分別是 應用層、V8引擎層、Node API層 和 LIBUV層。

• 應用層：   即 JavaScript 交互層，常見的就是 Node.js 的模塊，好比 http，fs
• V8引擎層：  即利用 V8 引擎來解析JavaScript 語法，進而和下層 API 交互
• NodeAPI層：  爲上層模塊提供系統調用，通常是由 C 語言來實現，和操做系統進行交互 。
• LIBUV層： 是跨平臺的底層封裝，實現了 事件循環、文件操做等，是 Node.js 實現異步的核心 。

不管是 Linux 平臺仍是 Windows 平臺，Node.js 內部都是經過 線程池 來完成異步 I/O 操做的，而 LIBUV 針對不一樣平臺的差別性實現了統一調用。所以，Node.js 的單線程僅僅是指 JavaScript 運行在單線程中，而並不是 Node.js 是單線程。

三、事件驅動模型

Node.js 實現異步的核心是事件驅動，也就是說，它把每個任務都當成 事件 來處理，而後經過 Event Loop 模擬了異步的效果，爲了更具體、更清晰的理解和接受這個事實，下面咱們用僞代碼來描述一下這個實現過程 。

【1】定義事件隊列

既然是隊列，那就是一個先進先出 (FIFO) 的數據結構，咱們用JS數組來描述，以下：

1 2 3 4 5 6 7

/**   * 定義事件隊列   * 入隊：push()   * 出隊：shift()   * 空隊列：length == 0   */ globalEventQueue: []

咱們利用數組來模擬隊列結構：數組的第一個元素是隊列的頭部，數組的最後一個元素是隊列的尾部，push() 就是在隊列尾部插入一個元素，shift() 就是從隊列頭部彈出一個元素。這樣就實現了一個簡單的事件隊列。

【2】定義接收請求入口

每個請求都會被攔截並進入處理函數，以下所示： 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/**   * 接收用戶請求   * 每個請求都會進入到該函數   * 傳遞參數request和response   */ processHttpRequest:function(request,response){            //定義一個事件對象      var  event  = createEvent({          params :request. params ,  //傳遞請求參數          result: null ,  //存放請求結果          callback:function(){}  //指定回調函數      });        //在隊列的尾部添加該事件        globalEventQueue.push( event ); }

這個函數很簡單，就是把用戶的請求包裝成事件，放到隊列裏，而後繼續接收其餘請求。

【3】定義 Event Loop

當主線程處於空閒時就開始循環事件隊列，因此咱們還要定義一個函數來循環事件隊列： 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

/**   * 事件循環主體，主線程擇機執行   * 循環遍歷事件隊列   * 處理非IO任務   * 處理IO任務   * 執行回調，返回給上層   */ eventLoop:function(){      //若是隊列不爲空，就繼續循環      while ( this .globalEventQueue.length > 0){                    //從隊列的頭部拿出一個事件          var  event  =  this .globalEventQueue.shift();                    //若是是耗時任務          if (isIOTask( event )){              //從線程池裏拿出一個線程              var  thread = getThreadFromThreadPool();              //交給線程處理              thread.handleIOTask( event )          } else  {              //非耗時任務處理後，直接返回結果              var  result = handleEvent( event );              //最終經過回調函數返回給V8，再由V8返回給應用程序              event .callback.call( null ,result);          }      } }

主線程不停的檢測事件隊列，對於 I/O 任務，就交給線程池來處理，非 I/O 任務就本身處理並返回。

【4】處理 I/O 任務

線程池接到任務之後，直接處理IO操做，好比讀取數據庫：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

/**   * 處理IO任務   * 完成後將事件添加到隊列尾部   * 釋放線程   */ handleIOTask:function( event ){      //當前線程      var  curThread =  this ;        //操做數據庫      var  optDatabase = function( params ,callback){          var  result = readDataFromDb( params );          callback.call( null ,result)      };            //執行IO任務      optDatabase( event . params ,function(result){          //返回結果存入事件對象中          event .result = result;            //IO完成後，將再也不是耗時任務          event .isIOTask =  false ;                    //將該事件從新添加到隊列的尾部          this .globalEventQueue.push( event );                    //釋放當前線程          releaseThread(curThread)      }) }

當 I/O 任務完成之後就執行回調，把請求結果存入事件中，並將該事件從新放入隊列中，等待循環，最後釋放當前線程，當主線程再次循環到該事件時，就直接處理了。

總結以上過程咱們發現，Node.js 只用了一個主線程來接收請求，但它接收請求之後並無直接作處理，而是放到了事件隊列中，而後又去接收其餘請求了，空閒的時候，再經過 Event Loop 來處理這些事件，從而實現了異步效果，固然對於IO類任務還須要依賴於系統層面的線程池來處理。

所以，咱們能夠簡單的理解爲：Node.js 自己是一個多線程平臺，而它對 JavaScript 層面的任務處理是單線程的。

四、CPU密集型是短板

至此，對於 Node.js 的單線程模型，咱們應該有了一個簡單而又清晰的認識，它經過事件驅動模型實現了高併發和異步 I/O，然而也有 Node.js 不擅長作的事情：

上面提到，若是是 I/O 任務，Node.js 就把任務交給線程池來異步處理，高效簡單，所以 Node.js 適合處理I/O密集型任務。但不是全部的任務都是 I/O 密集型任務，當碰到CPU密集型任務時，即只用CPU計算的操做，好比要對數據加解密(node.bcrypt.js)，數據壓縮和解壓(node-tar)，這時 Node.js 就會親自處理，一個一個的計算，前面的任務沒有執行完，後面的任務就只能乾等着 。以下圖所示：

在事件隊列中，若是前面的 CPU 計算任務沒有完成，後面的任務就會被阻塞，出現響應緩慢的狀況，若是操做系統自己就是單核，那也就算了，但如今大部分服務器都是多 CPU 或多核的，而 Node.js 只有一個 EventLoop，也就是隻佔用一個 CPU 內核，當 Node.js 被CPU 密集型任務佔用，致使其餘任務被阻塞時，卻還有 CPU 內核處於閒置狀態，形成資源浪費。

所以，Node.js 並不適合 CPU 密集型任務。

五、適用場景

• RESTful API: 請求和響應只需少許文本，而且不須要大量邏輯處理， 所以能夠併發處理數萬條鏈接。
• 聊天服務: 輕量級、高流量，沒有複雜的計算邏輯。