ACE主动对象模式(2)

最新推荐文章于 2021-05-26 23:21:50 发布

wzj_05

最新推荐文章于 2021-05-26 23:21:50 发布

阅读量353

点赞数

分类专栏： ACE

ACE 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

我们简单的介绍了一下ACE主动对象实现方式，同时提出了两个问题：

方法调用线程如何知道该方法已经执行完成？　
如何或得方法的返回值？

要解决这两个问题，首先得介绍一下ACE_Future对象，ACE_Future是表示一个会在将来被赋值的"期货"对象，可以通过ready()函数查询它是否已经被赋值。该对象创建的时候是未赋值的，后期可以通过set()函数来进行赋值，所赋的值可以通过get()函数来获取。

下面代码演示了它的基本用法：

    Cpp代码   
    
  
 #include "ace/Future.h"  
   
 #include <string>  
 #include <iostream>  
 using namespace std;  
   
 void get_info(ACE_Future<string> &fu)  
 {  
     string state = fu.ready()?"ready":"not ready";  
     cout<<endl<<state<<endl;  
     if(fu.ready())  
     {  
         string value;  
         fu.get(value);  
         cout<<"value:\t"<<value<<endl;  
     }  
 }  
   
 int main(int argc, char *argv[])  
 {  
     ACE_Future<string> fu;  
     get_info(fu);  
     fu.set("12345");  
     get_info(fu);  
   
     return 0;  
 }  

通过ACE_Future对象来解决上述两个问题的方法如下：

首先创建ACE_Future对象用以保留返回值。
调用主动命令时将ACE_Future对象作为参数传入，生成的命令对象中保存ACE_Future对象的指针。
命令执行线程执行完命令后，将返回值通过set()函数设置到ACE_Future对象中。
调用线程可以通过ACE_Future对象的ready()函数查询该命令是否执行完成，如果命令执行完成，则可通过get()函数来获取返回值。

使用的时候要注意一下ACE_Future对象的生命周期。

为了演示了如何获取主动命令的执行状态和结果，我将上篇文章中的代码改动了一下，日志类记录日志后，会将记录的内容作为返回值返回，该返回值会通过ACE_Future对象返回，代码如下：

    Cpp代码   
    
  
 #include "ace/OS.h"  
 #include "ace/Task.h"  
 #include "ace/Method_Object.h"  
 #include "ace/Activation_Queue.h"  
 #include "ace/Auto_Ptr.h"  
   
 #include "ace/Future.h"  
   
 #include <string>  
 #include <iostream>  
 using namespace std;  
   
 class Logger: public ACE_Task<ACE_MT_SYNCH>  
 {  
 public:  
     Logger()  
     {  
         this->activate();  
     }  
   
     int svc();  
     string LogMsg(const string& msg);  
     void LogMsgActive (const string& msg,ACE_Future<string> *result);  
   
 private:  
     ACE_Activation_Queue cmdQueue; //命令队列  
 };  
   
 class LogMsgCmd: public ACE_Method_Object  
 {  
 public:  
     LogMsgCmd(Logger *plog,const string& msg,ACE_Future<string> *result)  
     {  
         this->log=plog;  
         this->msg=msg;  
         this->result=result;  
     }  
   
     int call()  
     {  
         string reply = this->log->LogMsg(msg);  
         result->set(reply);  
         return 0;  
     }  
   
 private:  
     ACE_Future<string> *result;  
     Logger *log;  
     string msg;  
 };  
   
 string Logger::LogMsg(const string& msg)  
 {  
     ACE_OS::sleep(2);  
     cout<<endl<<msg<<endl;  
     return msg;  
 }  
   
 //以主动的方式记录日志  
 void Logger::LogMsgActive(const string& msg,ACE_Future<string> *result)  
 {  
     //生成命令对象，插入到命令队列中  
     cmdQueue.enqueue(new LogMsgCmd(this,msg,result));  
 }  
   
 int Logger::svc()  
 {  
     while(true)  
     {  
         //遍历命令队列，执行命令  
         auto_ptr<ACE_Method_Object> mo  
             (this->cmdQueue.dequeue ());  
   
         if (mo->call () == -1)  
             break;  
     }  
     return 0;  
 }  
   
 void get_info(ACE_Future<string> &fu)  
 {  
     string state = fu.ready()?"ready":"not ready";  
     cout<<endl<<state<<endl;  
     if(fu.ready())  
     {  
         string value;  
         fu.get(value);  
         cout<<"value:\t"<<value<<endl;  
     }  
 }  
   
 int main (int argc, ACE_TCHAR *argv[])  
 {  
     ACE_Future<string> result;  
     Logger log;  
     log.LogMsgActive ("hello",&result);  
   
     while(true)  
     {  
         get_info(result);  
         if(result.ready())  
             break;  
         ACE_OS::sleep(1);  
     }  
   
     cout<<endl<<"cmd end"<<endl;  
   
     while(true)  
         ACE_OS::sleep(1);  
   
     return 0;  
 }  

代码比较简单，这里就不多解释了。

这种查询模式比较简单有效，但存在一个问题：调用线程必须不断轮询ACE_Future对象以获取返回值，这样的效率比较低。可以通过观察者模式解决这个问题：在ACE_Future对象上注册一个观察者，当ACE_Future对象的值发生改变（异步命令执行完成）时主动通知该观察者，从而获取返回值。

ACE中的观察者模式可以通过ACE_Future_Observer来实现，使用方法如下：

    Cpp代码   
    
  
 #include "ace/Future.h"  
   
 #include <string>  
 #include <iostream>  
 using namespace std;  
   
 class MyObserver:public ACE_Future_Observer<string>  
 {  
     virtual void update (const ACE_Future<string> &future)  
     {  
         string value;  
         future.get(value);  
         cout<<endl<<"change:\t"<<value<<endl;  
     }  
 };  
   
 int main(int argc, char *argv[])  
 {  
     MyObserver obv;  
     ACE_Future<string> fu;  
   
     fu.attach(&obv);  
       
     ACE_OS::sleep(3);  
     fu.set("12345");  
   
     while(true)  
         ACE_OS::sleep(3);  
   
     return 0;  
 }  