DIV CSS 佈局教程網

Node.js 中的阻塞與非阻塞:從事件循環到子行程
編輯:關於JavaScript     

網上很多文章都說 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 的雙層架構

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 密集任務的首選。)

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved