上一篇介紹了 addon 的用法並實現了 sleep,今天繼續沿這條路,挖掘 C/C++ 的能力來彌補 Node 的短板。
就語言本身而言,Node 的性能相當不錯:不及多數靜態語言,但差距不大;與其他動態語言相比優勢明顯。那為什麼常說它不宜勝任 CPU 密集型場景?因為單線程特性使它在這類場景下無法充分利用多核心。
計算機科學裡有個著名的 Amdahl 定律:

設總工作量 W 可分為只能串行的 Ws 與允許並行的 Wp,則在 p 個 CPU 並行時,性能可提升 speedup 倍。它描述的是並行「能做到與不能做到」的邊界,是一種理想情況。現實要複雜得多:並發可能引起資源爭奪,需要加各種鎖,反而讓並行處於等待;並發還帶來內核線程調度切換的開銷,進一步增大 Ws。不過當 Wp 遠大於 Ws 且有多核心可用時,並行帶來的收益相當可觀。
回到 Node。我們設想一個計算場景:統計 400 以內的質數個數。這個任務以除法運算為主,不涉及內存與對象操作,理論上能讓 Node 跑出接近靜態語言的速度,便於對比。
JavaScript 版本:
function zhishu_js(num) {
if (num == 1) {
return false;
}
if (num == 2) {
return true;
}
for (var i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
等價的 C 語言版本:
#include <math.h>
bool zhishu(int num) {
if (num == 1) {
return false;
}
if (num == 2) {
return true;
}
for (int i = 2; i <= sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
};
Node 端用一個 1 到 4000000 的迴圈檢索;C 端則設置若干線程,共享一個計數器 count(初值 4000000),每個線程反覆取出 count 並判斷是否為質數,同時把 count 減一。JS 版本很直接:
var count = 0;
for (j = 1; j < 4000000; j++) {
if (zhishu(j)) {
count++;
}
}
早期 C/C++ 並未考慮並行需求,標準庫不提供多線程支持,而各操作系統的實現又有差異。為避免這種麻煩,這裡採用 pthread。
由於對 gyp 不熟,link 依賴 lib 折騰了很久沒搞定,最後採取了一個笨辦法:把 pthread 源碼直接放進項目目錄,並在 binding.gyp 中把它加入源碼列表,編譯時一并構建。修改後的配置:
{
"targets": [
{
"target_name": "hello",
"sources": [ "hello.cc", "pthreads/pthread.c" ],
"include_dirs": [
"<!(node -e \"require('nan')\")",
"pthreads"
],
"libraries": ["Ws2_32.lib"]
}
]
}
這方法很麻煩。如果你能正常引用 pthread 的 lib 與 include 目錄且不出現依賴問題,那當然最好,沒必要照搬。
接著定義線程處理函數:
pthread_mutex_t lock;
void *thread_p(void *null) {
int num, x = 0;
do {
pthread_mutex_lock(&lock);
num = count--;
pthread_mutex_unlock(&lock);
if (num > 0) {
if (zhishu(num)) x++;
} else {
break;
}
} while (true);
std::cout << ' ' << x << ' ';
pthread_exit(NULL);
return null;
}
線程之間對 count 是競爭關係,必須保證同時只有一個線程操作它,這裡用互斥鎖處理:pthread_mutex_lock(&lock) 時,線程檢查鎖狀態,已鎖定則等待並阻塞後續代碼,已釋放則加鎖並繼續;pthread_mutex_unlock(&lock) 解除鎖。
還有一個編譯器層面的坑:編譯時會做優化,若某語句沒有明確作用、對其他語句也無影響,會被直接優化掉。上例中我加了質數統計,若不加,像這樣的代碼:
for (int j = 0; j < 4000000; j++) {
zhishu(j);
}
會被編譯器整個跳過,實際根本不運行。這也是為什麼性能測試代碼裡常要累加結果並輸出,防止被優化掉。
addon 的寫法上一篇已介紹,這裡從 JS 接收一個參數表示線程數,然後在 C 中創建指定數量的線程完成檢索:
#include <nan.h>
#include <math.h>
#include <iostream>
#include "pthreads\pthread.h"
#define MAX_THREAD 100
using namespace v8;
int count = 4000000;
pthread_t tid[MAX_THREAD];
pthread_mutex_t lock;
void *thread_p(void *null) {
int num, x = 0;
do {
pthread_mutex_lock(&lock);
num = count--;
pthread_mutex_unlock(&lock);
if (num > 0) {
if (zhishu(num)) x++;
} else {
break;
}
} while (true);
std::cout << ' ' << x << ' ';
pthread_exit(NULL);
return null;
}
NAN_METHOD(Zhishu) {
NanScope();
pthread_mutex_init(&lock, NULL);
double arg0 = args[0]->NumberValue();
for (int j = 0; j < arg0 && j < MAX_THREAD; j++) {
pthread_create(&tid[j], NULL, thread_p, NULL);
}
for (int j = 0; j < arg0 && j < MAX_THREAD; j++) {
pthread_join(tid[j], NULL);
}
NanReturnUndefined();
}
void Init(Handle<Object> exports) {
exports->Set(NanSymbol("zhishu"),
FunctionTemplate::New(Zhishu)->GetFunction());
}
NODE_MODULE(hello, Init);
pthread_create 創建的線程默認是 joinable 的,此時子線程受制於主線程;pthread_join 會阻塞主線程等待子線程結束。若子線程已退出,join 不做任何事。因此對所有線程執行 join,可以保證全部結束後主線程才繼續。
var zhishu_c = require('./build/Release/hello.node').zhishu;
function zhishu(num) {
if (num == 1) return false;
if (num == 2) return true;
for (var i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) return false;
}
return true;
}
console.time("c");
zhishu_c(100);
console.timeEnd("c");
console.time("js");
var count = 0;
for (j = 1; j < 4000000; j++) {
if (zhishu(j)) count++;
}
console.log(count);
console.timeEnd("js");

單線程時,C/C++ 的運行速度約為 Node 的 181%,在動態語言中這個成績已經相當不錯。雙線程時提升最明顯——我的電腦是雙核四線程,此時已有兩個核心在處理。4 線程時達到極限,正好是雙核四線程的理論上限;再增加線程無法提速,反而會增加內核調度的時間與鎖的等待時間。用 Amdahl 定律來看,此時 p 已達上限 4,繼續增加線程時 Ws 的增長比並行收益更顯著,性能隨之下降。若在一臺空閒機器上做同樣實驗,數據應該會更好一些。
對於 CPU 密集型運算,交給靜態語言執行,效率提升相當可觀;若計算中大量涉及內存、字符串、數組、遞歸等操作,提升幅度可能更加驚人(這一點還需進一步驗證)。
同時,合理利用多線程確實能有效提高處理效率,但並非線程越多越好,需要根據機器實際情況配置——核心數、超線程與否、任務粒度都會影響最佳線程數。
Node 本身確實不擅長 CPU 密集任務,但有了 addon 這條路徑,這個障礙並非不可跨越。實務中的常見架構是:Node 負責 I/O 密集的請求接入與異步編排,把重計算任務卸給原生模塊、子進程或專門的計算服務,各展所長。