Node 的「事件循環」(Event Loop)是它能處理大並發、高吞吐的核心機制。也正因為有它,Node.js 大致上可以被理解為「單執行緒」——卻同時能在背景處理任意多的工作。以下拆解它的運作方式。
要理解事件循環,得先理解事件驅動編程(Event Driven Programming)。這個概念出現在 1960 年代,今日在 UI 開發中被大量使用。JavaScript 的主要用途之一是與 DOM 互動,因此天生就適合這種模式。
簡單定義:事件驅動編程以事件的發生或狀態的改變來控制程式流程,一般透過事件監聽實作——一旦偵測到事件(即狀態改變),就呼叫對應的回呼函式。這正是 Node.js 事件循環的基本原理。
如果你寫過客戶端 JavaScript,對那些 .on*() 方法應該不陌生,例如 element.onclick(),它們綁在 DOM 元素上處理使用者互動。這種模式允許在單一實例上觸發多個事件。Node.js 用 EventEmitter 來實作同一套模式,例如伺服器端的 Socket 與 http 模組。一個實例可以觸發一種以上的狀態改變。
另一個常見模式是表達成功與失敗。實作方式有兩種:一是把 Error 物件傳入回呼,慣例上放在第一個參數;二是使用 Promise 設計模式(ES6 已納入標準),它採用類似 jQuery 的鏈式寫法,避免深層回呼巢狀:
$.getJSON('/getUser').done(successHandler).fail(failHandler)
Node 的 fs 模組大多採用「把例外傳入回呼」的風格。技術上 fs.readFile() 也會觸發事件,但那個 API 只是用來表達操作成功或失敗的語意約定,屬於架構上的選擇,而非技術限制。
很多人以為 EventEmitter 在觸發事件時天生就是非同步的,這其實不對。看這段程式:
function MyEmitter() {
EventEmitter.call(this);
}
util.inherits(MyEmitter, EventEmitter);
MyEmitter.prototype.doStuff = function doStuff() {
console.log('before');
emitter.emit('fire');
console.log('after');
};
var me = new MyEmitter();
me.on('fire', function() {
console.log('emit fired');
});
me.doStuff();
// 輸出:
// before
// emit fired
// after
如果 emit 是非同步的,輸出應該會是 before → after → emit fired。實際上不是。
EventEmitter 之所以常讓人覺得像非同步,是因為它常用來通知那些需要非同步完成的操作,但 EventEmitter 的 API 本身完全是同步的。監聽函式內部當然可以寫成非同步,但請注意:所有監聽函式都會依註冊順序同步依序執行完畢。
Node 本身依賴多個函式庫,其中之一是 libuv——負責處理非同步事件佇列與執行的核心庫。
Node 盡可能把現成的功能委托給作業系統核心:生成回應、轉發連線等等。例如傳入的連線由作業系統佇列管理,等到 Node 有空時再處理。
你可能聽說 Node 有一個執行緒池,於是疑惑:「既然 Node 按順序處理任務,為什麼還需要執行緒池?」答案是:並非所有核心操作都是非同步的。遇到這種情況,Node.js 必須能暫時鎖住一個執行緒,好讓事件循環能繼續跑而不被阻塞。
示意圖:
┌───────────────────────┐
╭─▶│ timers │
│ └───────────┬───────────┘
│ ┌───────────┴───────────┐
│ │ pending callbacks │
│ └───────────┬───────────┘ ┌──────────────┐
│ ┌───────────┴───────────┐ │ incoming: │
│ │ poll │◀─┤ connections, │
│ └───────────┬───────────┘ │ data, etc. │
╰─▶│ setImmediate │ └──────────────┘
└───────────────────────┘
process.nextTick():所有透過它排程的回呼,都會在事件循環當前階段結束、轉換到下一階段之前執行。這個設計避免了遞迴呼叫 process.nextTick() 造成的無限循環(若它排到下一輪,遞迴就會永遠插隊)。
pending callbacks(待回呼):指那些不會被其他事件循環階段處理的回呼佇列,例如傳給 fs.write 的那些。
透過建立 EventEmitter,可以簡化與事件循環的互動。它是一個通用封裝,讓你更容易打造事件導向的 API。但兩者如何互動,往往正是開發者混淆的來源。
下面的例子示範:如果忘了事件是同步觸發的,事件就會被漏掉。
var EventEmitter = require('events');
var util = require('util');
function MyThing() {
EventEmitter.call(this);
doFirstThing();
this.emit('thing1'); // 在這裡就發掉了
}
util.inherits(MyThing, EventEmitter);
var mt = new MyThing();
mt.on('thing1', function onThing1() {
// 抱歉,這個事件永遠不會被 this 監聽到
});
問題很明顯:thing1 在 MyThing() 建構期間就觸發了,而監聽器要等 new 完成之後才註冊得上。
解法是用 setImmediate() 把觸發推到當前階段結束之後:
var EventEmitter = require('events');
var util = require('util');
function MyThing() {
EventEmitter.call(this);
doFirstThing();
setImmediate(emitThing1, this); // 延後觸發
}
util.inherits(MyThing, EventEmitter);
function emitThing1(self) {
self.emit('thing1');
}
var mt = new MyThing();
mt.on('thing1', function onThing1() {
// 這次執行到了
});
也可以這樣寫,但會損失一些效能(Function#bind 有額外開銷):
function MyThing() {
EventEmitter.call(this);
doFirstThing();
setImmediate(this.emit.bind(this, 'thing1'));
}
util.inherits(MyThing, EventEmitter);
找出應用程式裡的問題已經不容易,若再加上沒有呼叫堆疊(e.stack),幾乎無法除錯。當 Error 是從遠端非同步請求回來時,原始堆疊就已經掉了。有兩個可行的做法:同步觸發,或者確保 Error 與其他重要資訊一起傳遞。
MyThing.prototype.foo = function foo() {
// 這個 error 需要非同步觸發
var er = doFirstThing();
if (er) {
// 在觸發前先建立一個新的 Error,以保留當下的堆疊資訊
setImmediate(emitError, this, new Error('Bad stuff'));
return;
}
// 這個 error 可以馬上處理(同步觸發)
var er2 = doSecondThing();
if (er2) {
this.emit('error', 'More bad stuff');
return;
}
};
判斷標準在於「時機」:error 是否有可能被立即處理?還是它比較瑣碎、可以延後處理?另外,透過建構子把 Error 傳出去通常不是好主意,因為建構出來的物件實例很可能還不完整。剛才那個直接 throw 的情況算是例外。
• 不要在 process.nextTick 裡做重工作。它會卡在當前階段,阻塞 I/O。要讓出控制權給事件循環,用 setImmediate()。
• EventEmitter 的 'error' 事件是特例。若沒有任何監聽器,Node 會直接丟出例外並終止行程。任何會 emit error 的物件,都應該要有對應處理。
• 執行緒池預設只有 4 個執行緒。大量檔案 I/O 或 crypto 運算時,可透過 UV_THREADPOOL_SIZE 環境變數調大(要在行程啟動前設定才有效)。
• 單執行緒不等於不會阻塞。任何同步 API(fs.readFileSync、JSON.parse 巨大字串、大陣列的迴圈運算)都會卡住整個事件循環。這是 Node 效能問題最常見的根因。
事件循環的關鍵觀念可以濃縮成三句:EventEmitter 的觸發是同步的;process.nextTick 會插隊到當前階段結束前;setImmediate 則排到下一個階段。 把這三點分清楚,多數 Node 非同步行為的怪異現象都能解釋。
事件循環與作業系統核心的互動細節(epoll、kqueue、IOCP 在不同平台上的差異)則是另一個更大的主題,值得另外深入。