DIV CSS 佈局教程網

在 Node.js 中藉 addon 發揮多線程能力
編輯:關於JavaScript     

上一篇介紹了 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/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,可以保證全部結束後主線程才繼續。

JavaScript 端

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 密集的請求接入與異步編排,把重計算任務卸給原生模塊、子進程或專門的計算服務,各展所長。

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