網上很多文章都說 Node.js 是「異步的」,但異步到什麼程度,能講清楚的不多。這篇從一個會卡住的例子出發,把邊界講明白。
index.js:
var requestHandler = require("./requestHandler");
var server = require("./server");
var route = {
"/hello": requestHandler.hello,
"/upload": requestHandler.upload
};
server.start(route);
server.js:
var http = require("http");
var url = require("url");
exports.start = function(route) {
var server = http.createServer(function(req, res) {
var pathName = url.parse(req.url).pathname;
var handler = route[pathName];
if (handler) {
console.log("Through path:" + pathName + ":" + new Date().getTime());
handler(res);
} else {
res.writeHead(404, { "Content-Type": "text/plain" });
res.end();
}
});
server.listen(8088);
};
requestHandler.js:
exports.hello = function(res) {
res.writeHead(200, { "Content-Type": "text/plain" });
res.write("say hello.");
res.end();
};
exports.upload = function(res) {
res.writeHead(200, { "Content-Type": "text/plain" });
res.write("upload");
res.end();
};
在 cmd 中執行 node index.js 即可啟動。
上面的程式碼本身沒問題,但如果 createServer 的回調裡出現耗時計算,就會阻塞 Node 的事件輪詢。Node 高效的關鍵在於快速把控制权交還事件循環。
故意寫一個忙等待:
function sleep(milliSecond) {
var startTime = new Date().getTime();
console.log(startTime);
while (new Date().getTime() <= milliSecond + startTime) {}
console.log(new Date().getTime());
}
exports.hello = function(res) {
sleep(20000);
res.writeHead(200, { "Content-Type": "text/plain" });
res.write("say hello.");
res.end();
};
先訪問 https://localhost:8088/hello,再訪問 https://localhost:8088/upload。你會發現 upload 明明不耗時,卻必須等 hello 完全結束才回應。因為事件循環一直被 sleep 佔著,createServer 的回調無法及時返回。
formidable 的上傳經測試是非阻塞的。看它的源碼,關鍵在於:解析 headers 這段確實是同步的,但真正接收檔案資料是在 req.on('data') 裡,靠事件驅動完成。
IncomingForm.prototype.parse = function(req, cb) {
this.pause = function() {
try {
req.pause();
} catch (err) {
if (!this.ended) { this._error(err); }
return false;
}
return true;
};
this.resume = function() {
try {
req.resume();
} catch (err) {
if (!this.ended) { this._error(err); }
return false;
}
return true;
};
this.writeHeaders(req.headers);
var self = this;
req
.on('error', function(err) { self._error(err); })
.on('aborted', function() { self.emit('aborted'); })
.on('data', function(buffer) { self.write(buffer); })
.on('end', function() {
if (self.error) { return; }
var err = self._parser.end();
if (err) { self._error(err); }
});
if (cb) {
var fields = {}, files = {};
this
.on('field', function(name, value) { fields[name] = value; })
.on('file', function(name, file) { files[name] = file; })
.on('error', function(err) { cb(err, fields, files); })
.on('end', function() { cb(null, fields, files); });
}
return this;
};
也就是說,它的非阻塞能力完全建立在 Node 的事件分派架構之上——資料到達時才觸發回調,等待期間事件循環空出來處理其他請求。
像 sleep 那樣純粹消耗 CPU、又沒辦法靠事件驅動拆開的場景,可以借用類似 HTML5 WebWorker 的思路,用子行程把運算挪出去。
改造 requestHandler.js:
var childProcess = require("child_process");
exports.hello = function(res) {
var n = childProcess.fork(__dirname + "/subProcess.js");
n.on('message', function() {
res.writeHead(200, { "Content-Type": "text/plain" });
res.write("say hello.");
res.end();
});
n.send({});
};
exports.upload = function(res) {
res.writeHead(200, { "Content-Type": "text/plain" });
res.write("upload");
res.end();
};
新增 subProcess.js:
function sleep(milliSecond) {
var startTime = new Date().getTime();
console.log(startTime);
while (new Date().getTime() <= milliSecond + startTime) {}
console.log(new Date().getTime());
}
process.on('message', function() {
sleep(20000);
process.send({});
});
此時再測試,hello 還在等待,upload 已經回應了。
Node 是 C++ 與 JavaScript 的雙層架構,而且是單執行緒的,這點尤其重要。Node 本質上是 C++ 通過 V8 調用 JS,為了維護調用順序而維護了一個事件序列。因此在一個 JS 函數內部,它的執行必然會阻塞其他函數。
網上常提到的 process.nextTick 和 setTimeout 都不會產生新執行緒,它們解決的只是事件序列中的元素順序問題:process.nextTick 直接把回調塞到序列最頂端,實現簡單;setTimeout 則額外開了一個 C++ 執行緒計時,時間到了再把回調放進序列。
以 file IO 為例,readFile 的第二個參數是回調。Node 先記下回調,然後調用底層 C++。從「調用 C++ 開始」到「觸發回調」這段確實是異步的——但那已經發生在 C++ 層,不在 JS 層。http.createServer 到觸發回調、mysql 的 socket 發送命令再等待回應,都是同一個道理。
所以結論是:Node 的異步是 I/O 異步,不是 CPU 異步。一旦在 JS 端出現耗時運算,唯一的出路就是把運算搬到別的執行緒或行程去,就像上面用 child_process.fork 做的那樣。那個 subprocess.js 不在 Node 的事件序列內部維護,是獨立行程,因此不會阻塞其他 JS 函數。
(延伸一句:Node 12 之後有了 worker_threads,比 fork 行程更輕量,共享記憶體的溝通成本也更低,是現代專案處理 CPU 密集任務的首選。)