2. 程式人生 > >NodeJS C++ Addons之C++類例項包裝與非同步操作

NodeJS C++ Addons之C++類例項包裝與非同步操作

阿新 • • 發佈：2019-01-26

本文是對NodeJS C++ Addons原生寫法的進一步探索，介紹了利用原生的Node和V8提供的API實現類包裝和非同步呼叫的具體做法。在閱讀本文之前，如果對NodeJS C++ Addons的基礎不熟悉的話，建議先閱讀上一篇部落格【NodeJS C++ Addons基礎】進行了解之後再回來閱讀本文。

本文所使用的程式碼示例可以從該倉庫中找到–【cpp-addons】

備註： 本文旨在探究NodeJS C++ Addons的原生寫法，瞭解部分底層知識，所使用的NodeJS版本為8.11.1，由於V8原生的API會發生變動，不同版本的NodeJS的支援情況可能不同。因此不保證程式碼能相容所有版本的NodeJS。

一、C++類和物件例項的包裝

NodeJS C++外掛除了可以向JavaScript提供函式介面之外，還可以將一些C++類或者C++物件例項包裝後直接提供給JavaScript使用。舉個例子，假設有個用C++實現的類，類名為SomeClass，現在想要在JavaScript中直接使用該類，通過new SomeClass(...)直接建立該類的例項並進行使用。

接下來將使用一個簡單的例子來說明如何進行C++類和物件的包裝。在這個例子中，將實現一個C++類Accumulator，該類是一個累加器，提供add()和getAddTimes()兩個方法，add()方法用於將引數累加並返回當前的累加值，getAddTimes()

則是返回當前的累加次數。在建立Accumulator例項的時候，可以指定累加開始的初始值。最後，我們期望實現的效果如下，可以在JavaScript中使用這個C++類並建立該類的例項，並且可以呼叫該類上定義的方法。

// cpp-object-wrap demo
const AccumulatorModule = require('./build/Release/Accumulator')
let acc = new AccumulatorModule.Accumulator(2)
console.log('[ObjectWrapDemo] 2 + 12 = ' + acc.add(12))
console.log('[ObjectWrapDemo] 2 + 12 + 5 = '
 
 + acc.add(5))
console.log('[ObjectWrapDemo] add times: ' + acc.getAddTimes())

在C++中，Accumulator是一個通過class關鍵字定義的普通類，而在JavaScript中，一個類即為一個JS函式。在C++中，Accumulator的例項是一個普通的C++類例項，在JavaScript中，一個例項即為一個JS物件。JS函式在V8中對應的是一個v8::Function例項，JS物件在V8中對應的是一個v8::Object例項，因此，包裝要做的事情，便是將一個C++類包裝成一個v8::Function例項，將一個C++例項物件包裝成一個v8::Object例項，然後提供給JavaScript使用。下面是該C++外掛的實現原始碼，註釋包含了對包裝過程的介紹。

#include <node.h>
#include <node_object_wrap.h>

namespace CppObjectWrapDemo {
  using v8::Context;
  using v8::Function;
  using v8::FunctionCallbackInfo;
  using v8::FunctionTemplate;
  using v8::Isolate;
  using v8::Local;
  using v8::Number;
  using v8::Object;
  using v8::Persistent;
  using v8::String;
  using v8::Value;
  using v8::Exception;

  /* 將C++類封裝給JS使用，需要繼承node::ObjectWrap */
  class Accumulator : public node::ObjectWrap {
    public:
      /* 初始化該類的JS建構函式，並返回JS建構函式 */
      static Local<Function> init (Isolate* isolate) {
        /* 利用函式模板，將一個C++函式包裝成JS函式 */
        Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, AccumulatorJS);
        tpl->SetClassName(String::NewFromUtf8(isolate, "Accumulator"));
        tpl->InstanceTemplate()->SetInternalFieldCount(1);
        /* 類方法定義在建構函式的prototype上 */
        NODE_SET_PROTOTYPE_METHOD(tpl, "add", add);
        NODE_SET_PROTOTYPE_METHOD(tpl, "getAddTimes", getAddTimes);
        /* 獲取Accumulator類的JS建構函式 */
        Local<Function> fn = tpl->GetFunction();
        /* JS建構函式控制代碼儲存於constructor上，後續還會使用到 */
        constructor.Reset(isolate, fn);
        return fn;
      }
    private:
      /* 成員變數 */
      static Persistent<Function> constructor;
      double value;
      int addTimes;

      /* 該類的C++建構函式，設定成員變數初始值 */
      explicit Accumulator (double initValue = 0) {
        this->value = initValue;
        this->addTimes = 0;
      }

      /* 該類的JS建構函式，建立該類的物件，幷包裝成JS物件然後進行返回 */
      static void AccumulatorJS (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        if (args.IsConstructCall()) {/* 通過 new Accumulator() 建立物件 */
          /* 提取引數數值 */
          double val = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
          /* 建立該類的例項物件 */
          Accumulator* obj = new Accumulator(val);
          /* 包裝該物件 */
          obj->Wrap(args.This());
          /* 返回該物件 */
          args.GetReturnValue().Set(args.This());
        } else {/* 通過直接呼叫函式 Accumulator() 建立物件，丟擲異常 */
          isolate->ThrowException(Exception::TypeError(
            String::NewFromUtf8(isolate, "Should use the new operator to create an instance.")
          ));
        }
      }

      /* 該類的成員方法，增加value的值 */
      static void add (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        /* 將被包裝的JS物件還原為C++物件 */
        Accumulator* obj = node::ObjectWrap::Unwrap<Accumulator>(args.Holder());
        /* 訪問C++物件上的成員變數進行操作 */
        obj->value += args[0]->NumberValue();
        obj->addTimes += 1;
        args.GetReturnValue().Set(Number::New(isolate, obj->value));
      }

      /* 該類的成員方法，獲取累加次數 */
      static void getAddTimes (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        /* 將被包裝的JS物件還原為C++物件 */
        Accumulator* obj = node::ObjectWrap::Unwrap<Accumulator>(args.Holder());
        args.GetReturnValue().Set(Number::New(isolate, obj->addTimes));
      }
  };

  Persistent<Function> Accumulator::constructor;

  void init (Local<Object> exports) {
    Isolate* isolate = exports->GetIsolate();
    /* 初始化Accumulator類的JS建構函式 */
    Local<Function> _Accumulator = Accumulator::init(isolate);
    /* 將Accumulator類的JS建構函式暴露給JS使用 */
    /* 這裡不能使用NODE_SET_METHOD，因為NODE_SET_METHOD是暴露一個C++函式給JS使用 */
    /* NODE_SET_METHOD(exports, "Accumulator", _Accumulator); */
    /* 此處是暴露一個JS函式，它在C++裡面表示為一個Function物件，不是一個C++函式 */
    /* 要通過設定屬性的方法將其掛到exports上 */
    exports->Set(String::NewFromUtf8(isolate, "Accumulator"), _Accumulator);
  }

  NODE_MODULE(NODE_GYP_MODULE_NAME, init)
}

進行C++類包裝，需要引入標頭檔案<node_object_wrap.h>，被包裝的類需要繼承node::ObjectWrap類。被包裝的C++類除了擁有自己的C++建構函式之外，還需要有一個JS建構函式，C++建構函式在建立該類的C++例項的時候會被呼叫，而JS建構函式則是在JavaScript中建立該類的物件的時候會被呼叫。在JS建構函式中寫好當JS建立C++類例項的時候要進行的操作，然後將該JS建構函式包裝成一個v8::Function提供給JavaScript使用。以上面程式碼為例，AccumulatorJS是該類的JS建構函式，在AccumulatorJS執行的時候，會建立一個C++類例項，然後將該例項包裝變成一個v8::Object之後返回。AccumulatorJS本身是一個C++函式，為了能在JS中呼叫到它，需要先在Accumulator::init方法利用FunctionTemplate根據AccumulatorJS定製出一個JS函式。

在JS中，使用函式來實現類，類的成員方法一般定義在建構函式的原型（prototype）上。在Accumulator::init方法中，使用NODE_SET_PROTOTYPE_METHOD來將C++類的成員方法掛到JS建構函式的原型上。這樣做以後，在JS中創建出該類的例項後，便可以呼叫到這些成員方法了。

該類的成員方法add()和getAddTimes()會在JS中被呼叫，所以在呼叫時也會得到const FunctionCallbackInfo<Value>& args引數。可以通過args引數來進行獲取JS傳遞過來的引數資訊以及設定返回值等操作。由於在這兩個成員方法中，需要訪問到類例項上成員變數，因此需要先將發起呼叫的JS物件解包裝，還原成C++例項。解包裝時候會用到node::ObjectWrap::Unwrap<Accumulator>(args.Holder())，args.Holder()可以獲取到發起呼叫的JS物件例項。

實現了類和物件例項的包裝以後，便可以將相關介面暴露給JS使用了。跟其他C++外掛模組一樣，也是通過module.exports屬性來暴露相關介面。這裡需要注意的點在程式碼註釋中也有說明，由於我們暴露給JS使用的東西是一個JS建構函式，而不是普通的C++函式，所以不能使用NODE_SET_METHOD來設定暴露的內容，而是直接通過exports物件的Set()方法來進行設定。

完成之後將下面內容寫入binding.gyp，進行編譯構建，得到.node檔案後便可以利用前面展示的JS程式碼去進行測試了。JS程式碼執行後的輸出結果如圖所示，可以驗證通過類和物件例項的包裝，JS能夠直接使用C++的類和例項。

{
  "targets": [{
    "target_name": "accumulator",
    "sources": ["accumulator.cc"]
  }]
}

C++類和物件包裝例項

二、C++類例項工廠

前面展示瞭如何將一個C++類進行包裝然後暴露給JavaScript使用。在使用過程中，JavaScript能夠直接通過new操作符來建立該類的例項。現在，我們希望C++模組能夠提供一個工廠函式，JavaScript呼叫該工廠函式之後也可以獲取到該C++類的例項，而不需要通過new操作符來建立例項。繼續在前面的Accumulator例子上進行改進，以探索實現C++向JavaScript提供類例項工廠函式的方法。

給Accumulator增加getInstance()方法，通過Accumulator::getInstance()方法，可以在C++程式碼裡面主動呼叫Accumulator類的JS建構函式，從而建立一個類例項並將類例項包裝成JS物件，達到與在JS中使用new操作符時同樣的目的。下面是程式碼展示，部分操作在註釋中有進行說明。

#include <node.h>
#include <node_object_wrap.h>

namespace CppObjectWrapDemo {
  using v8::Context;
  using v8::Function;
  using v8::FunctionCallbackInfo;
  using v8::FunctionTemplate;
  using v8::Isolate;
  using v8::Local;
  using v8::Number;
  using v8::Object;
  using v8::Persistent;
  using v8::String;
  using v8::Value;
  using v8::Exception;

  /* 將C++類封裝給JS使用，需要繼承node::ObjectWrap */
  class Accumulator : public node::ObjectWrap {
    public:
      /* 初始化該類的JS建構函式，並返回JS建構函式 */
      static Local<Function> init (Isolate* isolate) {
        /* 利用函式模板，將一個C++函式包裝成JS函式 */
        Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, AccumulatorJS);
        tpl->SetClassName(String::NewFromUtf8(isolate, "Accumulator"));
        tpl->InstanceTemplate()->SetInternalFieldCount(1);
        /* 類方法定義在建構函式的prototype上 */
        NODE_SET_PROTOTYPE_METHOD(tpl, "add", add);
        NODE_SET_PROTOTYPE_METHOD(tpl, "getAddTimes", getAddTimes);
        /* 獲取Accumulator類的JS建構函式 */
        Local<Function> fn = tpl->GetFunction();
        /* JS建構函式控制代碼儲存於constructor上，後續還會使用到 */
        constructor.Reset(isolate, fn);
        return fn;
      }

      /* 獲取該類例項的工廠函式 */
      static void getInstance (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        Local<Value> argv[1] = { args[0] };
        /* 獲取當前上下文 */
        Local<Context> context = isolate->GetCurrentContext();
        /* 生成JS建構函式 */
        Local<Function> _constructor = Local<Function>::New(isolate, constructor);
        /* 建立例項 */
        Local<Object> obj = _constructor->NewInstance(context, 1, argv).ToLocalChecked();
        /* 返回例項 */
        args.GetReturnValue().Set(obj);
      }
    private:
      /* 成員變數 */
      static Persistent<Function> constructor;
      double value;
      int addTimes;

      /* 該類的C++建構函式，設定成員變數初始值 */
      explicit Accumulator (double initValue = 0) {
        this->value = initValue;
        this->addTimes = 0;
      }

      /* 該類的JS建構函式，建立該類的物件，幷包裝成JS物件然後進行返回 */
      static void AccumulatorJS (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        if (args.IsConstructCall()) {/* 通過 new Accumulator() 建立物件 */
          /* 提取引數數值 */
          double val = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
          /* 建立該類的例項物件 */
          Accumulator* obj = new Accumulator(val);
          /* 包裝該物件 */
          obj->Wrap(args.This());
          /* 返回該物件 */
          args.GetReturnValue().Set(args.This());
        } else {/* 通過直接呼叫函式 Accumulator() 建立物件，丟擲異常 */
          isolate->ThrowException(Exception::TypeError(
            String::NewFromUtf8(isolate, "Should use the new operator to create an instance.")
          ));
        }
      }

      /* 該類的成員方法，增加value的值 */
      static void add (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        /* 將被包裝的JS物件還原為C++物件 */
        Accumulator* obj = node::ObjectWrap::Unwrap<Accumulator>(args.Holder());
        /* 訪問C++物件上的成員變數進行操作 */
        obj->value += args[0]->NumberValue();
        obj->addTimes += 1;
        args.GetReturnValue().Set(Number::New(isolate, obj->value));
      }

      /* 該類的成員方法，獲取累加次數 */
      static void getAddTimes (const FunctionCallbackInfo<Value>& args) {
        Isolate* isolate = args.GetIsolate();
        /* 將被包裝的JS物件還原為C++物件 */
        Accumulator* obj = node::ObjectWrap::Unwrap<Accumulator>(args.Holder());
        args.GetReturnValue().Set(Number::New(isolate, obj->addTimes));
      }
  };

  Persistent<Function> Accumulator::constructor;

  void getAccumulatorInstance(const FunctionCallbackInfo<Value>& args) {
    Accumulator::getInstance(args);
  }

  void init (Local<Object> exports) {
    Isolate* isolate = exports->GetIsolate();
    /* 初始化Accumulator類的JS建構函式 */
    Local<Function> _Accumulator = Accumulator::init(isolate);
    /* 將Accumulator類的JS建構函式暴露給JS使用 */
    /* 這裡不能使用NODE_SET_METHOD，因為NODE_SET_METHOD是暴露一個C++函式給JS使用 */
    /* NODE_SET_METHOD(exports, "Accumulator", _Accumulator); */
    /* 此處是暴露一個JS函式，它在C++裡面表示為一個Function物件，不是一個C++函式 */
    /* 要通過設定屬性的方法將其掛到exports上 */
    exports->Set(String::NewFromUtf8(isolate, "Accumulator"), _Accumulator);
    /* 將獲取例項的工廠方法暴露給JS */
    NODE_SET_METHOD(exports, "getAccumulatorInstance", getAccumulatorInstance);
  }

  NODE_MODULE(NODE_GYP_MODULE_NAME, init)
}

Accumulator::getInstance()方法中，利用_constructor的NewInstance()方法可以建立一個例項，執行該方法的作用相當於JS中使用new操作符時候的作用，也會呼叫對應的JS建構函式，從而創建出該類的例項幷包裝成一個JS物件進行返回。

Accumulator::getInstance()方法在C++中呼叫，為了將其暴露給JavaScript使用，在最後還需要建立一個getAccumulatorInstance()函式，在這個函式裡面完成對Accumulator::getInstance()的呼叫。將getAccumulatorInstance()掛到exports屬性上後便可提供給JavaScript使用了。

可使用下面的JS程式碼對C++模組進行檢驗，程式碼輸出如圖所示。JavaScript能夠呼叫C++模組提供的工廠函式，從而獲得一個C++類的例項並且可以對該例項進行使用，呼叫該類所定義的成員方法。

// cpp-object-wrap-factory demo
const AccumulatorModule = require('./build/Release/Accumulator')
let acc2 = AccumulatorModule.getAccumulatorInstance(3)
console.log('[ObjectWrapFactoryDemo] 3 + 16 = ' + acc2.add(16))
console.log('[ObjectWrapFactoryDemo] 3 + 16 + 7 = ' + acc2.add(7))
console.log('[ObjectWrapFactoryDemo] 3 + 16 + 7 + 4 = ' + acc2.add(4))
console.log('[ObjectWrapFactoryDemo] add times: ' + acc2.getAddTimes())

C++類例項工廠例項

三、非同步操作

NodeJS C++外掛可以提供介面給JavaScript使用，在上一篇部落格【NodeJS C++ Addons基礎】也已經給出不少示例。不過，在之前的示例中，實現的都是同步呼叫。按照之前的做法，JavaScript呼叫C++外掛模組提供的介面後，會阻塞JavaScript程式碼的執行。同步呼叫帶來的阻塞不符合JavaScript非同步的特點，在遇到複雜耗時的任務時，這種阻塞更是嚴重影響應用的效能。為了解決這個問題，就需要實現非同步呼叫，使得C++外掛模組的介面在被呼叫後不會阻塞JavaScript的執行。

實現非同步操作需要用到libuv這個庫，libuv是一個跨平臺的抽象庫，它實現了Node.js的事件迴圈、工作執行緒、以及平臺所有的的非同步操作。利用libuv可以很方便地讓C++外掛模組的介面非同步化。接下來將對上一篇部落格【NodeJS C++ Addons基礎】中的使用的累加求和的例子進行改進，實現非同步呼叫。下面是改進後的程式碼，在註釋中會對部分操作進行闡述。

#include <uv.h>
#include <node.h>
#include <vector>

namespace AsyncDemo {
  using v8::Function;
  using v8::FunctionCallbackInfo;
  using v8::Isolate;
  using v8::Local;
  using v8::Number;
  using v8::Object;
  using v8::Value;
  using v8::Null;
  using v8::Exception;
  using v8::String;
  using v8::Undefined;
  using v8::Persistent;
  using v8::HandleScope;

  /* 存放資料供子執行緒使用的結構體 */
  struct Data {
    /* 回撥函式 */
    Persistent<Function> callback;
    /* 求和引數 */
    std::vector<double> args;
    /* 求和結果 */
    double result;
  };

  /* 子執行緒執行的程式碼 */
  void calculate (uv_work_t* req) {
    Data* data = static_cast<Data*>(req->data);
    /* 遍歷引數進行求和 */
    data->result = 0.0;
    for (int i = 0; i < data->args.size(); ++i) {
      data->result += data->args[i];
    }
  }

  /* 子執行緒結束後執行的程式碼 */
  void calculateComplete (uv_work_t* req) {
    Data* data = static_cast<Data*>(req->data);
    Isolate* isolate = Isolate::GetCurrent();
    /* 必須建立一個HandleScope，否則後面無法建立控制代碼 */
    HandleScope handleScope(isolate);
    /* 將求和結果轉換為一個JS Number */
    Local<Value> argv[1] = { Number::New(isolate, data->result) };
    /* 通過回撥函式返回求和結果 */
    Local<Function> cb = Local<Function>::New(isolate, data->callback);
    cb->Call(Null(isolate), 1, argv);
    /* 回撥完成後清除資源 */
    data->callback.Reset();
    delete data;
    delete req;
  }

  void accumulateAsync (const FunctionCallbackInfo<Value>& args) {
    Isolate* isolate = args.GetIsolate();
    /* 引數不合理異常 */
    if (args.Length() < 1) {
      isolate->ThrowException(Exception::TypeError(
        String::NewFromUtf8(isolate, "Arguments Number Error.")
      ));
      return;
    }

    /* 沒有回撥函式 */
    if (!args[args.Length() - 1]->IsFunction()) {
      isolate->ThrowException(Exception::TypeError(
        String::NewFromUtf8(isolate, "No Callback Error.")
      ));
      return;
    }

    /* 提取通過引數傳遞的回撥函式 */
    Local<Function> callback = Local<Function>::Cast(args[args.Length() - 1]);
    /* 建立Data結構體儲存資料 */
    Data* data = new Data();
    /* 儲存回撥函式 */
    data->callback.Reset(isolate, callback);
    /* 提取引數並存儲到data */
    for (int i = 0; i < args.Length() - 1; ++i) {
      /* 如果引數不是數字，向js丟擲異常 */
      if (!args[i]->IsNumber()) {
        isolate->ThrowException(Exception::TypeError(
          String::NewFromUtf8(isolate, "Arguments Type Error.")
        ));
        return;
      } else {
        data->args.push_back(args[i]->NumberValue());
      }
    }

    /* 啟動工作執行緒進行求和計算 */
    uv_work_t *req = new uv_work_t();
    req->data = data;
    uv_queue_work(
      uv_default_loop(),
      req,
      (uv_work_cb)calculate,
      (uv_after_work_cb)calculateComplete
    );

    /* 本函式直接返回，無需等待執行緒計算完成 */
    args.GetReturnValue().Set(Undefined(isolate));
  }

  void init (Local<Object> exports) {
    NODE_SET_METHOD(exports, "accumulateAsync", accumulateAsync);
  }

  NODE_MODULE(NODE_GYP_MODULE_NAME, init)
}

使用libuv這個庫，需要包含標頭檔案<uv.h>。利用uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb, uv_after_work_cb after_work_cb)這個方法將任務傳送到執行緒池，指明子執行緒的執行函式work_cb和回撥函式after_work_cb後，子執行緒會執行work_cb，並且線上程執行完畢後回撥after_work_cb。uv_work_t* req用來存放發起執行緒呼叫的請求資訊，在執行函式work_cb和回撥函式after_work_cb中可以通過req來獲取主執行緒想要子執行緒處理的資料。在記憶體上，執行緒不共享棧，但是共享堆，因此，主執行緒可以通過一個結構體來包裝資料然後在堆上建立該結構體的例項，子執行緒通過指標去堆上獲取該結構體例項便可以獲取到主執行緒想要傳遞的資料，也可以通過這個例項將資料返回給主執行緒。

以上面程式碼為例，在accumulateAsync()方法中，完成引數檢查和提取以後，便可以開啟一個子執行緒去對資料進行操作計算，不必等待子執行緒結束直接返回。JavaScript呼叫accumulateAsync()方法之後，實際上是開啟了一個子執行緒去完成求和過程，accumulateAsync()方法呼叫後馬上返回，因此不會阻塞到後續的JavaScript程式碼的執行。子執行緒的執行函式calculate會完成求和計算過程，並將求和結果存放到Data結構體的一個例項中，子執行緒執行完畢後會喚醒主執行緒，執行回撥函式calculateComplete，在calculateComplete中完成對JavaScript回撥函式的呼叫，將求和結果通過回撥函式回傳給JavaScript。

結構體Data中，儲存JS回撥函式的控制代碼時需要使用Persistent控制代碼，Persistent控制代碼需要主動執行程式碼進行釋放，與之相對的Local控制代碼會在函式呼叫結束後控制代碼作用域消失時被釋放，失去控制代碼引用的變數會被V8的垃圾清理機制自動清除。由於子執行緒執行時主執行緒的accumulateAsync()方法已經結束返回了，為了讓回撥函式不會清理，在子執行緒結束後能夠順利完成回撥JavaScript，這裡必須使用Persistent控制代碼。

將以下內容寫入檔案binding.gyp，完成編譯構建得到.node檔案。

{
  "targets": [{
    "target_name": "accumulate_async",
    "sources": ["accumulate_async.cc"]
  }]
}

使用以下JS程式碼進行測試，輸出結果如圖所示，可以看到先輸出的語句是Hi~，由於實現了非同步呼叫，求和過程不會阻塞JavaScript程式碼的執行，因此在呼叫accumulateAsync()之後，跟在後面的console.log('[AsyncDemo] Hi~')不會被阻塞，正常執行。

// async-demo
const AccumulateAsync = require('./build/Release/accumulate_async')
AccumulateAsync.accumulateAsync(1, 3, 4, 7, (sum) => {
  console.log('[AsyncDemo] 1 + 3 + 4 + 7 = ' + sum)
})
console.log('[AsyncDemo] Hi~')

非同步呼叫例項

四、小結

實現C++類和例項的包裝，讓JavaScript能夠直接使用到C++類和例項，這個過程的操作雖然繁瑣了一點，但也不是太難，<node_object_wrap.h>中提供的API已經可以很方便地實現這個功能。實現C++外掛介面的非同步化，讓JavaScript能夠進行非同步呼叫而不被阻塞，需要用到多執行緒的知識。在NodeJS官方文件中對如何使用libuv進行非同步操作並沒有相關例子展示，所以在寫前面的例子的時候也比較折騰。libuv的API文件比較晦澀，幸好網上還有另一份介紹文件【An Introduction to libuv】，這份文件中除了對一些概念和API進行介紹之外，也會有給出程式碼示例，對初學者來說比較友好。

相關推薦

NodeJS C++ Addons之C++類例項包裝與非同步操作

本文是對NodeJS C++ Addons原生寫法的進一步探索，介紹了利用原生的Node和V8提供的API實現類包裝和非同步呼叫的具體做法。在閱讀本文之前，如果對NodeJS C++ Addons的基礎不熟悉的話，建議先閱讀上一篇部落格【NodeJS C++ A

【C#】之SqlHelper類+配置檔案？

說說 在上一篇的七層登陸中，我們簡單的說了sqlhelper層的作用，簡單來講就是將資料訪問層中涉及到與資料庫操作的程式碼，全部封裝到一個類當中，這樣一來，涉及到資料訪問時，直接呼叫裡面的程式碼即可，減少了程式碼量。 當然在七層登陸中我們也講到了配置檔案與反射，它位於工廠層，通過

C++STL之string類的使用

使用 string 類的標頭檔案：#include<string>，不是#include<string.h>，後面有.h的是C語言的庫。 string 也是 STL標準庫中的一個容器。 1.string的構造：                    

C++（筆記）類例項

//定義一個Person類，成員變數age(年齡),和name(姓名),成員函式getName(),getAge(),setAge(int newAge),完成該類測試 #include <iostream> #include "Person.h"

C++標準庫vector類型的使用和操作總結

種類 style 開始 spa log string string類 gpo targe 　　vector是一種類型對象的集合，它是一種順序容器，容器中的所有對象必須都是同一種類型。vector的對象是可以動態生長的，這說明它在初始化時可以不用指定大小，而是再使用時根據元素

c# 第30節 類字段與屬性

esp OS thread col value || tex inf isp 本節內容： 1：字段是什麽 2：屬性判斷字段的安全 3：對屬性的解釋 1：字段是什麽 字段其實在上一節我們就使用過了：再來詳細的說他一說 amespace cw {

初識C語言之基本編程思想與基本概念掃盲

預編譯 mingw 1.5 集成開發環境 運算 集成 思想 多任務 運行程序 h3 { margin-top: 0.46cm; margin-bottom: 0.46cm; direction: ltr; line-height: 173%; text-align: jus

嵌入式C語言之C語言的高階表達與指標的高階應用

指標陣列與陣列指標、函式指標：                   指標陣列  int *p[5]   相當於int *(p[5])  （陣

C/C++知識點之C/C++經典面試題一

本文主要向大家介紹了 C/C++知識點之C/C++經典面試題一，通過具體的內容向大家展示，希望對大家學習C/C++知識點有所幫助。 1.變數的宣告和定義有什麼區別？ 常量：在程式執行過程中，不會發生改變的量，不能被改變的量 變數：在程式執行過程中，可以被改變的量 定義變數的方式：資料型別

C符號之邏輯運算子 左移與右移 自增自減

                本篇文章將總結C中一些比較有趣的符號邏輯運算子：“ || ” 與 “ && ” 是比較常用的邏輯運算子，分別是 或 和 與。或（||）：雙目運算子。兩者中任一為真即為真。與（ &&）：雙目運算子。兩者都為真時才為真，任一為假即為假。但是，這兩個運

C++學習之deque底層儲存結構與迭代器失效情況

C++ STL容器deque和vector很類似，也是採用動態陣列來管理元素。 使用deque之前需包含標頭檔案： #include <deque> 它是定義在名稱空間std內的一個class template： template<class _

C# 面向物件：類、根據不同操作符操作兩個變數

類 1、當使用類時，應新增一個新類 2、類名首字母需大寫 3、欄位用來儲存資料，private；屬性用來保護欄位；介面、建構函式、方法 public struct1 { // 自動屬性：雖然沒有寫欄位，但是還是會生

c++實現單例類（懶漢與餓漢）

 懶漢與餓漢 　　單例大約有兩種實現方法：懶漢與餓漢。 懶漢：故名思義，不到萬不得已就不會去例項化類，也就是說在第一次用到類例項的時候才會去例項化，所以上邊的經典方法被歸為懶漢實現；餓漢：餓了肯定要飢不擇食。所以在單例類定義的時候就進行例項化。 　　特點與選擇： 由於要進行執行緒同步，所以在訪問量

c++初級 之 c++的封裝性

c++作為面向物件的程式語言，有三大特性：封裝性、繼承性、多型性。 此篇說明封裝性：什麼是封裝？自己的理解就是將很多同類事物（比如狗類）的共同特性（名字、顏色、跑、叫、吃）封裝起來，然後遇到一個該類事物（一隻具體的狗）時，就可以直接使用從該類事物封裝好的這些特性。用類和物件

C語言之庫函式的模擬與使用

  C語言之庫函式的模擬與使用   在我們學習C語言的過程中，難免會遇到這樣的一種情況： 我們通常實現一個功能的時候，費盡心血的寫出來，卻有著滿滿的錯，這時卻有人來告訴你說：這個功能可以用相應的庫函式來實現。 這時你的心裡充滿著***。但這並不算壞事，至少加深了你對它的認識與記憶。 &nb

二次加工系統的標準類型 包裝與授權

標準類型 賦值 時間顯示 get 定義 加工 完成 自動 import # 二次加工系統的標準類型 # 1、通過繼承系統的類來完成包裝, 定制自己的數據類型 class List(list): # 定義了一個List類，繼承自系統中的list類 def app

halcon影象採集之同步（synchronous）與非同步（asynchronous）

通常情況下，當我們抓取幀的時候是從一個連續的視訊流序列中去抓取一個或者多個視訊幀。儘管近來有許多的專業裝置使用數字訊號，但大多數情況下，視訊訊號是模擬訊號（analog）。最常見的模擬視訊格式是

資料結構與演算法基礎(二)之單鏈表的插入與刪除操作

今天主要來講一講單鏈表的插入與刪除操作的步驟和演算法解釋。這是單鏈表最基本的操作但是也是最重要的基礎之一，有些地方還比較容易出錯。下面我就結合原始碼在上面加上註釋來解釋每一步的作用。 **一、單鏈表的插入操作** 1、圖示（截圖來自網易雲課

Java多執行緒基礎之物件鎖的同步與非同步

同步：synchronized 同步的概念就是共享，如果不是共享的資源，就沒有必要進行同步。 非同步：asynchronized 非同步的概念就是獨立，相互之間不受到任何制約。 同步的目的就是為了執行緒安全，對於

C語言之變量和數據類型

更改 地址 輸入 name style span 控制臺 標示 otto 常量:程序在運行過程中無法對值進行更改。 變量:是在計算機內存空間一種表示，聲明變量將會向計算機內存申請存儲空間，用於保存數據，計算機的CPU會從內存中加載數據。 聲明變量: 數據類型 變量名[=值