某个产品的Mac客户端计划基于electron实现，因为现有SDK有C API，原理上用NodeJS Addon来封装成JS API就可使用了。但涉及到与Addon多线程交互，翻找资料没能找到到底该怎么做，只好翻看NodeJS实现找到实现思路。
实现思路上，NodeJS V8 引擎是libuv单线程的，客户端前台页面逻辑跑在libuv事件循环中，后台SDK跑在独立的线程上。业务需要前后台线程之间互相通信，前台访问后台直接API调用，然后异步回调、后台通知则需要唤醒libuv线程来完成。
libuv 唯一线程安全的接口是 uv_async_send, 用它可以唤醒libuv线程执行指定代码。
后台SDK -> NodeJS 调用流程：
0. SDK 实例初试化时
初试化一个uv_async_t：
uv_async_init(uv_default_loop(), &uv_async, node_event_process);
注意必须在libuv线程线程执行，node_event_process 是被唤醒时执行的方法。
1. 将参数临时存放在SDK实例
2. 唤醒libuv线程
uv_async_send(&uv_async)
libuv 在UNIX下的实现是，uv_async_init时创建一个namepipe fd， 在epoll等待，send时就是往fd写入数据，epoll就会返回。
要注意的是uv_async_send每次调用并不保证都会执行回调，只保证能唤醒线程，不能作为调用方式。
3. SDK线程执行 std::condition_variable.wait() 挂起等待libuv线程执行结果
4. libuv线程唤醒，读取SDK实例临时参数执行node_event_process调用
通过V8接口，调用JSON库，将参数解析为V8 Object对象
通过CallID查找事务回调的CallBack Function，或者提供bind方法绑定的Callback Function，执行调用就会返回Javascript世界开始执行
5. 执行完成，将返回值临时放到SDK实例上
返回v8::Local<v8::Value> 需先处理为自己的类型，传递到SDK线程读取会导致崩溃
6. std::condition_variable.notify_one() 唤醒SDK线程继续执行
7. SDK wait() 继续执行，读取返回值
参考代码如下:
class RcsSdk : public Nan::ObjectWrap {
public:
static NAN_MODULE_INIT(Init);
void addCallback(int cid, Nan::Callback* callback);
const Nan::Callback* removeCallback(int cid);
const Nan::Callback* getBindMethod(const char* method);
void notifyMainLoop();
#ifdef CALL_NODE_USE_ASYNC_QUEUE
std::queue<EventItem*> asyncEventQueue;
#else
void waitForEventProcess(EventItem* item);
void notifyEventComplete();
EventItem* syncEventItem;
char* syncEventResult;
#endif
std::mutex eventSyncMutex;
rcs_state *state;
private:
explicit RcsSdk(const char* appId, const char* number, const char* imei,
const char* devicevendor,const char* devicemodel,
const char* deviceos,const char* deviceosversion,
const char* clientVendor, const char* clientVersion,
const char* storage, const char* privateStorage, int clientType);
~RcsSdk();
static NAN_METHOD(New);
static NAN_METHOD(bind);
static void addApiMethods(v8::Local<v8::FunctionTemplate> &tpl);
static Nan::Persistent<v8::Function> constructor;
std::condition_variable eventCondition;
uv_async_t uv_async;
std::map<int, const Nan::Callback*> callbacks;
std::map<std::string, const Nan::Callback*> bindMethods;
};
static std::map<rcs_state*, RcsSdk*> sdkMap;
static std::mutex globalMutex;
static RcsSdk* node_get_sdk(rcs_state *R){
RcsSdk *sdk = NULL;
globalMutex.lock();
std::map<rcs_state*, RcsSdk*>::iterator iterator = sdkMap.find(R);
if(iterator != sdkMap.end()){
sdk = iterator->second;
}
globalMutex.unlock();
return sdk;
}
char* node_event_deliver(struct rcs_state *R, const char* event, const char* json){
//LuaSdk 后台线程
LOG_DEBUG("node_event_deliver begin, event:%s json:%s", event, json);
RcsSdk* sdk = node_get_sdk(R);
char* result = NULL;
if(NULL == sdk){
LOG_DEBUG("node_event_deliver sdk NULL");
return NULL;
}
EventItem item;
item.event = event;
item.data = (char *)json;
sdk->waitForEventProcess(&item);
sdk->eventSyncMutex.lock();
result = sdk->syncEventResult;
sdk->eventSyncMutex.unlock();
LOG_DEBUG("node_event_deliver end");
return result;
}
static int node_get_cid(v8::Handle<v8::Value> json){
int cid = -1;
if(json->IsObject()){
v8::Handle<v8::Object> ojson = json->ToObject();
cid = ojson->Get(Nan::New("id").ToLocalChecked())->Int32Value();
}
return cid;
}
static v8::Handle<v8::Value> parseJson(v8::Handle<v8::Value> jsonString) {
// Call JSON.parse.apply(JSON, jsonString)
v8::Handle<v8::Context> context = Nan::GetCurrentContext();
v8::Handle<v8::Object> global = context->Global();
v8::Handle<v8::Object> JSON = global->Get(Nan::New("JSON").ToLocalChecked())->ToObject();
v8::Handle<v8::Function> JSON_parse =v8::Handle<v8::Function>::Cast(JSON->Get(Nan::New("parse").ToLocalChecked()));
return JSON_parse->Call(JSON, 1, &jsonString);
}
static v8::Local<v8::Value> node_do_event_process(RcsSdk* sdk, EventItem *item){
v8::Handle<v8::Value> json = parseJson(Nan::New(item->data).ToLocalChecked());
v8::Local<v8::Value> argv[] = {json};
v8::Local<v8::Value> result;
if(!std::strcmp(item->event, "callback")){
int cid = node_get_cid(json);
LOG_DEBUG("node api callback cid:%d", cid);
const Nan::Callback * callback = sdk->removeCallback(cid);
if(NULL == callback){
LOG_ERROR("node api callback=NULL");
}else{
result = callback->Call(1, argv);
delete callback;
}
}else{
LOG_DEBUG("node_do_event_process:%s %s", item->event, item->data);
const Nan::Callback * callback = sdk->getBindMethod(item->event);
if(NULL == callback){
LOG_DEBUG("node listener callback=NULL");
}else{
result = callback->Call(1, argv);
}
}
return result;
}
// SDK线程调用 uv_async_send 后，主线程被唤醒后执行
// uv_async_send 是libuv唯一线程安全的API，但不保证每次调用都通知到，只是能确保至少一次的唤醒主线程
// 参见: http://docs.libuv.org/en/v1.x/async.html
// int uv_async_send(uv_async_t* async)
// Wakeup the event loop and call the async handle’s callback.
//
// Note It’s safe to call this function from any thread. The callback will be
// called on the loop thread.
// Warning libuv will coalesce calls to uv_async_send(), that is, not every call to
// it will yield an execution of the callback. For example: if uv_async_send() is
// called 5 times in a row before the callback is called, the callback will only be
// called once. If uv_async_send() is called again after the callback was called, it
// will be called again.
static void node_event_process(uv_async_t *handle){
//nodejs 主线程
LOG_DEBUG("node_event_process begin");
Nan::HandleScope scope;
RcsSdk *sdk = (RcsSdk*)handle->data;
sdk->eventSyncMutex.lock();
EventItem *item = sdk->syncEventItem;
sdk->syncEventItem = NULL;
sdk->eventSyncMutex.unlock();
if(NULL == item){
LOG_ERROR("node_event_process sync syncEventItem=NULL");
}else{
v8::Local<v8::Value> ret = node_do_event_process(sdk, item);
char *result = NULL;
// 暂只支持返回String类型(必须在主线程解析v8对象)
if(!ret.IsEmpty() && ret->IsString()){
result = *Nan::Utf8String(v8::Local<v8::String>::Cast(ret));
}
// 此处分配内存，由下次调用前释放，最多保留上一次的结果占用的内存
if(result != NULL){
char* cpy = (char*)RCS_MALLOC(strlen(result)+1);
assert(cpy);
strcpy(cpy, result);
result = cpy;
}
sdk->eventSyncMutex.lock();
sdk->syncEventResult = result;
sdk->eventSyncMutex.unlock();
}
sdk->notifyEventComplete();
LOG_DEBUG("node_event_process end");
}
// RcsSdk Imps
Nan::Persistent<v8::Function> RcsSdk::constructor;
NAN_MODULE_INIT(RcsSdk::Init) {
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
tpl->SetClassName(Nan::New("RcsSdk").ToLocalChecked());
//这个数只要>0即可
tpl->InstanceTemplate()->SetInternalFieldCount(1);
//构建Js 的ProtoType
Nan::SetPrototypeMethod(tpl, "bind", bind);
addApiMethods(tpl);
constructor.Reset(Nan::GetFunction(tpl).ToLocalChecked());
Nan::Set(target, Nan::New("RcsSdk").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
}
RcsSdk::RcsSdk(const char* number, const char* imei, const char* devicevendor,
const char* devicemodel, const char* deviceos, const char* deviceosversion,
const char* clientVendor, const char* clientVersion, const char* storage,
const char* appId, const char* syspath, int clientType)
#ifndef CALL_NODE_USE_ASYNC_QUEUE
:syncEventItem(NULL),
syncEventResult(NULL)
#endif
{
LOG_DEBUG("begin initSdk: %s %s %s %s %s", appId, number, clientVendor, clientVersion, storage);
state = rcs_state_new();
rcs_listeners listeners;
node_get_listeners(listeners);
rcs_set_listeners(state, &listeners);
rcs_callbacks callbacks;
node_get_callbacks(callbacks);
rcs_set_callbacks(state, &callbacks);
// 每个State上有且只有一个用于中断主线程的 uv_async_t
uv_async_init(uv_default_loop(), &uv_async, node_event_process);
uv_async.data = this;
rcs_init(state, number, imei, "node-imsi",
devicevendor, devicemodel, deviceos, deviceosversion,
clientVendor,clientVersion, storage, appId, syspath, clientType);
rcs_start(state);
globalMutex.lock();
sdkMap[state] = this;
globalMutex.unlock();
}
RcsSdk::~RcsSdk() {
if(state){
rcs_stop(state, 0);
globalMutex.lock();
sdkMap.erase(state);
globalMutex.unlock();
state = NULL;
}
}
void RcsSdk::addCallback(int cid, Nan::Callback* callback){
callbacks[cid] = callback;
}
const Nan::Callback* RcsSdk::removeCallback(int cid){
std::map<int, const Nan::Callback*>::iterator iterator = callbacks.find(cid);
const Nan::Callback* callback = NULL;
if(iterator != callbacks.end()){
callback = iterator->second;
callbacks.erase(iterator);
}
return callback;
}
const Nan::Callback* RcsSdk::getBindMethod(const char* method){
std::map<std::string, const Nan::Callback*>::iterator iterator = bindMethods.find(method);
if(iterator != bindMethods.end()){
return iterator->second;
}
return NULL;
}
void RcsSdk::notifyMainLoop(){
uv_async_send(&uv_async);
}
NAN_METHOD(RcsSdk::New) {
if (!info.IsConstructCall()) {
// Invoked as plain function `RcsSdk(...)`, turn into construct call.
const int argc = info.Length();
v8::Local<v8::Value> argv[12];
for(int i=0; i<argc; i++){
argv[i] = info[i];
}
v8::Local<v8::Function> cons = Nan::New(constructor);
info.GetReturnValue().Set(cons->NewInstance(argc, argv));
} else {
// Invoked as constructor: `new RcsSdk(...)`
if(info.Length() != 12){
Nan::ThrowError(Nan::Error("Wrong number of arguments"));
return;
}
CHECK_ARGS_STRING(info, 0, "number");
CHECK_ARGS_STRING(info, 1, "imei");
CHECK_ARGS_STRING(info, 2, "devicevendor");
CHECK_ARGS_STRING(info, 3, "devicemodel");
CHECK_ARGS_STRING(info, 4, "deviceos");
CHECK_ARGS_STRING(info, 5, "deviceosversion");
CHECK_ARGS_STRING(info, 6, "clientVendor");
CHECK_ARGS_STRING(info, 7, "clientVersion");
CHECK_ARGS_STRING(info, 8, "storage");
CHECK_ARGS_STRING(info, 9, "appId");
CHECK_ARGS_STRING(info, 10, "sysPath");
CHECK_ARGS_NUMBER(info, 11, "clientType");
const char* number = *Nan::Utf8String(info[0]);
const char* imei = *Nan::Utf8String(info[1]);
const char* devicevendor = *Nan::Utf8String(info[2]);
const char* devicemodel = *Nan::Utf8String(info[3]);
const char* deviceos = *Nan::Utf8String(info[4]);
const char* deviceosversion = *Nan::Utf8String(info[5]);
const char* clientVendor = *Nan::Utf8String(info[6]);
const char* clientVersion = *Nan::Utf8String(info[7]);
const char* storage = *Nan::Utf8String(info[8]);
const char* appId = *Nan::Utf8String(info[9]);
const char* sysPath = *Nan::Utf8String(info[10]);
int clientType = info[11]->Uint32Value();
RcsSdk *sdk = new RcsSdk(number, imei, devicevendor, devicemodel, deviceos, deviceosversion,
clientVendor, clientVersion, storage, appId, sysPath, clientType);
sdk->Wrap(info.This());
info.GetReturnValue().Set(info.This());
}
}
NAN_METHOD(RcsSdk::bind) {
RcsSdk* sdk = Nan::ObjectWrap::Unwrap<RcsSdk>(info.This());
if(info.Length() != 2 || ! info[0]->IsString() || !info[1]->IsFunction()){
Nan::ThrowError(Nan::Error("Wrong arguments"));
return;
}
const char* method = *Nan::Utf8String(info[0]);
Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
sdk->bindMethods[method] = callback;
}