node libuv异步多线程使用初窥

5550阅读　0评论2014-01-02　ygfinsight
分类：C/C++

libuv介绍：
libuv 是node.js作者写的，是 Node 的新跨平台抽象层，用于抽象 Windows 的 IOCP 及 Unix 的 libev。作者打算在这个库的包含所有平台的差异性。 
特性： ibuv 严格使用 异步 、 事件驱动 的编程风格。其核心工作是提供事件循环及基于 I/O 或其他活动事件的回调机制，非阻塞 TCP 套接字 非阻塞命名管道 UDP 定时器 子进程生成 通过 uv_getaddrinfo 实现异步 DNS 异步文件系统 API：uv_fs_* 高分辨率时间：uv_hrtime 正在运行程序路径查找：uv_exepath 线程池调度：uv_queue_work TTY控制的ANSI转义代码: uv_tty_t 文件系统事件现在支持 inotify, ReadDirectoryChangesW 和 kqueue。很快会支持事件端口：uv_fs_event_t 进程间的 IPC 与套接字共享：uv_write2 
自己写的一个小例子：
client.h

点击(此处)折叠或打开

  1. #ifndef CLIENTTEST_H_
  2. #define CLIENTTEST_H_

  4. #include <v8.h>
  5. #include <node.h>
  6. #include <node_object_wrap.h>

  8. using namespace node;
  9. using namespace v8;

  11. class ClientTest : ObjectWrap {
  12. public:
  13.     ClientTest(){}
  14.     ~ClientTest(){}
  15.     //构造并初始化对外的函数或方法给js使用
  16.     static void Init(Handle<Object> target);
  17.     //对外的构造对象的New函数
  18.     static Handle<Value> New(const Arguments& args);
  19.     //对外的异步方法
  20.     static Handle<Value> connect(const Arguments& args);
  21.     //异步工作函数
  22.     static void connectWork(uv_work_t* req);
  23.     //异步工作函数结束之后调用的函数
  24.     static void afterConnect(uv_work_t* req, int status);
  25.     //测试函数
  26.     static Handle<Value> test(const Arguments& args);

  28.     //获取构造函数，需要自己释放
  29.     static Persistent<FunctionTemplate> constructorTemplate;

  31. };

  33. #endif
baton.h

点击(此处)折叠或打开

  1. #ifndef BATON_H_
  2. #define BATON_H_
  3. #include <node.h>
  4. #include <v8.h>
  5. #include <uv.h>
  6. #include <string>
  7. #include "client.h"

  9. using namespace v8;

  11. class Baton{
  12. public:
  13.     Baton(ClientTest*c,Handle<Function>*callback);
  14.     ~Baton();
  15.     /*存放回调函数,使用persistent来声明,让程序不会在函数结束后自动回收
  16.      当回调成功后,使用discope释放空间
  17.     */
  18.     Persistent<Function> callback;
  19.     
  20.     
  21.     //错误信息
  22.     bool err;
  23.     std::string *errMsg;
  24.     //运行需要的参数
  25.     ClientTest *client;
  26.     std::string hostname;
  27.     std::string user;
  28.     std::string password;


  31. };
  32. #endif
utils.h(第三方提供)

点击(此处)折叠或打开

  1. #ifndef _util_h_
  2. #define _util_h_

  4. #include <string>
  5. #include <sstream>
  6. #include <stdio.h>
  7. #include <stdlib.h>

  9. //判断参数是否是bool类型,如果不是，做异常处理
  10. #define REQ_BOOL_ARG(I, VAR) \
  11.     if (args.Length() <= (I) || !args[I]->IsBoolean()) \
  12.     return ThrowException(Exception::TypeError(String::New("Argument " #I " must be a bool"))); \
  13.     bool VAR = args[I]->IsTrue();
  14. //判断参数是否是string类型,并作转化
  15. #define REQ_STRING_ARG(I, VAR) \
  16.     if (args.Length() <= (I) || !args[I]->IsString()) \
  17.     return ThrowException(Exception::TypeError(String::New("Argument " #I " must be a string"))); \
  18.     Local<String> VAR = Local<String>::Cast(args[I]);
  19. //判断参数是否是数组类型
  20. #define REQ_ARRAY_ARG(I, VAR) \
  21.     if (args.Length() <= (I) || !args[I]->IsArray()) \
  22.     return ThrowException(Exception::TypeError(String::New("Argument " #I " must be an array"))); \
  23.     Local<Array> VAR = Local<Array>::Cast(args[I]);
  24. //判断参数是否是函数类型
  25. #define REQ_FUN_ARG(I, VAR) \
  26.     if (args.Length() <= (I) || !args[I]->IsFunction()) \
  27.     return ThrowException(Exception::TypeError(String::New("Argument " #I " must be a function"))); \
  28.     Local<Function> VAR = Local<Function>::Cast(args[I]);
  29. //判断参数是否是对象类型并将对象转化为Local<Object>
  30. #define REQ_OBJECT_ARG(I, VAR) \
  31.     if (args.Length() <= (I) || !args[I]->IsObject()) \
  32.     return ThrowException(Exception::TypeError(String::New("Argument " #I " must be an object"))); \
  33.     Local<Object> VAR = Local<Object>::Cast(args[I]);
  34. //给对象的某一字符串变量赋值var是变量，key是用来赋值的关键字
  35. #define OBJ_GET_STRING(OBJ, KEY, VAR) \
  36.   { \
  37.   Local<Value> __val = OBJ->Get(String::New(KEY)); \
  38.   if(__val->IsString()) { \
  39.   String::Utf8Value __utf8Val(__val); \
  40.   VAR = *__utf8Val; \
  41.   } \
  42.   }

  44. //给对象的某一数值类型赋值
  45. #define OBJ_GET_NUMBER(OBJ, KEY, VAR, DEFAULT) \
  46.   { \
  47.   Local<Value> __val = OBJ->Get(String::New(KEY)); \
  48.   if(__val->IsNumber()) { \
  49.   VAR = __val->ToNumber()->Value(); \
  50.   } \
  51.     else if(__val->IsString()) { \
  52.     String::Utf8Value __utf8Value(__val); \
  53.     VAR = atoi(*__utf8Value); \
  54.     } else { \
  55.     VAR = DEFAULT; \
  56.     } \
  57.   }


  60. #endif
client.cpp

点击(此处)折叠或打开

  1. #include <iostream>
  2. #include "client.h"
  3. #include "baton.h"
  4. #include "utils.h"

  6. Persistent<FunctionTemplate> ClientTest::constructorTemplate;
  7. void ClientTest::Init(Handle<Object> target)
  8. {
  9.     HandleScope scope;

  11.     //定义一个函数模板
  12.     Local<FunctionTemplate> t = FunctionTemplate::New(New);
  13.     constructorTemplate = Persistent<FunctionTemplate>::New(t);
  14.     constructorTemplate->InstanceTemplate()->SetInternalFieldCount(1);
  15.     constructorTemplate->SetClassName(String::NewSymbol("ClientTestTest"));

  17.     NODE_SET_PROTOTYPE_METHOD(constructorTemplate,"connection",connect);
  18.     NODE_SET_PROTOTYPE_METHOD(constructorTemplate,"test",test);
  19.     target->Set(String::NewSymbol("ClientTest"),constructorTemplate->GetFunction());
  20. }

  22. Handle<Value> ClientTest::New(const Arguments& args)
  23. {
  24.     HandleScope scope;
  25.     ClientTest *client = new ClientTest();//实例化一个Client对象，用指针client指向
  26.     client->Wrap(args.This()); //包裹client对象
  27.     return scope.Close(args.This());//返回这个对象给外部使用
  28. }

  30. Handle<Value> ClientTest::connect(const Arguments& args)
  31. {
  32.     HandleScope scope;
  33.     //把第一个参数js对象转换成C++可用的对象
  34.     REQ_OBJECT_ARG(0, settings);
  35.     //回调函数的判断并转化
  36.     REQ_FUN_ARG(1, callback);
  37.     //将node.js的对象包装成C++对象
  38.     ClientTest* client = ObjectWrap::Unwrap<ClientTest>(args.This());
  39.     //构建一个baton 对象
  40.     Baton* baton = new Baton(client, &callback);
  41.     //获取对象字符串并赋值
  42.     OBJ_GET_STRING(settings, "hostname", baton->hostname);
  43.     OBJ_GET_STRING(settings, "user", baton->user);
  44.     OBJ_GET_STRING(settings, "password", baton->password);

  46.     client->Ref();
  47.     uv_work_t* req = new uv_work_t();
  48.     req->data = baton;
  49.     //将任务加入到工作队列
  50.     uv_queue_work(uv_default_loop(), req, connectWork, (uv_after_work_cb)afterConnect);
  51.     //返回
  52.     return scope.Close(Undefined());

  54. }
  55. void ClientTest::connectWork(uv_work_t* req)
  56. {
  57.     //Baton 类型指针做转化
  58.     Baton *baton = static_cast<Baton*>(req->data);
  59.     baton->errMsg = NULL;
  60.     baton->err = false;
  61.     //模拟工作,这里省去了异常处理
  62.     std::cout<<"I am connecting!"<<std::endl;
  63. }

  65. void ClientTest::afterConnect(uv_work_t* req, int status)
  66. {
  67.     HandleScope scope;
  68.     Baton* baton = static_cast<Baton*>(req->data);
  69.     baton->client->Unref();
  70.     Handle<Value> argv[2];
  71.     if(baton->err) {
  72.         argv[0] = Exception::Error(String::New(baton->errMsg->c_str()));
  73.         argv[1] = Undefined();
  74.     } else {
  75.         argv[0] = Undefined();
  76.         //构造client对象
  77.         Handle<Object> client = ClientTest::constructorTemplate->GetFunction()->NewInstance();
  78.         //对象作为回调函数第二个参数
  79.         argv[1] = client;
  80.     }
  81.     //执行回调返回
  82.     node::MakeCallback(Context::GetCurrent()->Global(), baton->callback, 2, argv);
  83.     //删除对象
  84.     delete baton;
  85. }

  87. Handle<Value> ClientTest::test(const Arguments& args)
  88. {
  89.     HandleScope scope;
  90.     return scope.Close(String::New("Hello World!"));
  91. }
baton.cpp

点击(此处)折叠或打开

  1. #include "baton.h"
  2. using namespace v8;

  4. Baton::Baton(ClientTest*c,Handle<Function> *callback)
  5. {
  6.     this->client = c;
  7.     if (callback!=NULL)
  8.     {
  9.         this->callback = Persistent<Function>::New(*callback);
  10.     }
  11.     else
  12.     {
  13.         this->callback = Persistent<Function>();
  14.     }
  15.     this->err = false;
  16.     this->errMsg = NULL;
  17.     this->hostname = "127.0.0.1";
  18.     this->user = " ";
  19.     this->password = " ";
  20. }
  21. Baton::~Baton()
  22. {
  23.     callback.Dispose();
  24.     if(errMsg)
  25.     {
  26.         delete errMsg;
  27.     }
  28. }
asyn.cpp

点击(此处)折叠或打开

  1. #include "baton.h"
  2. #include "client.h"


  5. extern "C" {
  6.     static void init(Handle<Object> target) {
  7.         ClientTest::Init(target);
  8.     
  9.     }
  10.     NODE_MODULE(asyn,init);
  11. }

js代码：

点击(此处)折叠或打开

  1. var addon = require('./asyn');

  3. var connData = {
  4.     "hostname":'localhost',
  5.     "user":'admin',
  6.     "passwd":'admin123'
  7. };
  8. var conn = new addon.ClientTest();

  10. var res = conn.connection(connData,function(err,connect){
  11.     if (err) {
  12.         console.log(err);
  13.     }else
  14.     {
  15.         
  16.         console.log(connect.test());    
  17.     }
  18. });
  19. console.log('ecec before test');
执行结果

 由执行结果可以看出，执行过程中异步执行并不阻塞后续的任务，所以先打印了exec before test.
上一篇：关于windows下vs2010能够定义一个类的空指针并且能够调用类的成员函数说明
下一篇：vs2010在头文件中实现了函数出现的问题