ACE主动对象模式(1)

主动对象模式用于降低方法执行和方法调用之间的耦合。该模式描述了另外一种更为透明的任务间通信方法。

传统上，所有的对象都是被动的代码段，对象中的代码是在对它发出方法调用的线程中执行的，当方法被调用时，调用线程将阻塞，直至调用结束。而主动对象却不一样。这些对象具有自己的命令执行线程，主动对象的方法将在自己的执行线程中执行，不会阻塞调用方法。

例如，设想对象"A"已在你的程序的main()函数中被实例化。当你的程序启动时，OS创建一个线程，以从main()函数开始执行。如果你调用对象A的任何方法，该线程将"流过"那个方法，并执行其中的代码。一旦执行完成，该线程返回调用该方法的点并继续它的执行。但是，如果"A"是主动对象，事情就不是这样了。在这种情况下，主线程不会被主动对象借用。相反，当"A"的方法被调用时，方法的执行发生在主动对象持有的线程中。另一种思考方法：如果调用的是被动对象的方法（常规对象），调用会阻塞（同步的）；而另一方面，如果调用的是主动对象的方法，调用不会阻塞（异步的）。

由于主动对象的方法调用不会阻塞，这样就提高了系统响应速度，在网络编程中是大有用武之地的。

在这里我们将一个"Logger"（日志记录器）对象对象为例来介绍如何将一个传统对象改造为主动对象，从而提高系统响应速度。

Logger的功能是将一些系统事件的记录在存储器上以备查询，由于Logger使用慢速的I/O系统来记录发送给它的消息，因此对Logger的操作将会导致系统长时间的等待。

其功能代码简化如下：

Cpp代码  

1. class Logger: public ACE_Task<ACE_MT_SYNCH>  
2. {  
3. public:  
4.     void LogMsg(const string& msg)  
5.     {  
6.         cout<<endl<<msg<<endl;  
7.         ACE_OS::sleep(2);  
8.     }  
9. };  

 

为了实现实现记录日志操作的主动执行，我们需要用命令模式将其封装，从而使得记录日志的方法能在合适的时间和地方主动执行，封装方式如下：

Cpp代码  

1. class LogMsgCmd: public ACE_Method_Object  
2. {  
3. public:  
4.     LogMsgCmd(Logger *plog,const string& msg)  
5.     {  
6.         this->log=plog;  
7.         this->msg=msg;  
8.     }  
9.   
10.     int call()  
11.     {  
12.         this->log->LogMsg(msg);  
13.         return 0;  
14.     }  
15.   
16. private:  
17.     Logger *log;  
18.     string msg;  
19. };  
20.   
21. class Logger: public ACE_Task<ACE_MT_SYNCH>  
22. {  
23. public:  
24.     void LogMsg(const string& msg)  
25.     {  
26.         cout<<endl<<msg<<endl;  
27.         ACE_OS::sleep(2);  
28.     }  
29.   
30.     LogMsgCmd *LogMsgActive(const string& msg)  
31.     {  
32.         new LogMsgCmd(this,msg);  
33.     }  
34. };  

 

这里对代码功能做一下简单的说明：

ACE_Method_Object是ACE提供的命令模式借口，命令接口调用函数为int call()，在这里通过它可以把每个操作日志的调用封装为一个LogMsgCmd对象，这样，当原来需要调用LogMsg的方法的地方只要调用LogMsgActive即可生成一个LogMsgCmd对象，由于调用LogMsgActive方法，只是对命令进行了封装，并没有进行日志操作，所以该方法会立即返回。然后再新开一个线程，将LogMsgCmd对象作为参数传入，在该线程中执行LogMsgCmd对象的call方法，从而实现无阻塞调用。

然而，每次对一个LogMsg调用都开启一个新线程，无疑是对资源的一种浪费，实际上我们往往将生成的LogMsgCmd对象插入一个命令队列中，只新开一个命令执行线程依次执行命令队列中的所有命令。并且，为了实现对象的封装，命令队列和命令执行线程往往也封装到Logger对象中，代码如下所示：

Cpp代码  

1. #include "ace/OS.h"  
2. #include "ace/Task.h"  
3. #include "ace/Method_Object.h"  
4. #include "ace/Activation_Queue.h"  
5. #include "ace/Auto_Ptr.h"  
6.   
7. #include <string>  
8. #include <iostream>  
9. using namespace std;  
10.   
11. class Logger: public ACE_Task<ACE_MT_SYNCH>  
12. {  
13. public:  
14.     Logger()  
15.     {  
16.         this->activate();  
17.     }  
18.   
19.     int svc();  
20.     void LogMsg(const string& msg);  
21.     void LogMsgActive (const string& msg);  
22.   
23. private:  
24.     ACE_Activation_Queue cmdQueue;    //命令队列  
25. };  
26.   
27. class LogMsgCmd: public ACE_Method_Object  
28. {  
29. public:  
30.     LogMsgCmd(Logger *plog,const string& msg)  
31.     {  
32.         this->log=plog;  
33.         this->msg=msg;  
34.     }  
35.   
36.     int call()  
37.     {  
38.         this->log->LogMsg(msg);  
39.         return 0;  
40.     }  
41.   
42. private:  
43.     Logger *log;  
44.     string msg;  
45. };  
46.   
47. void Logger::LogMsg(const string& msg)  
48. {  
49.     cout<<endl<<msg<<endl;  
50.     ACE_OS::sleep(2);  
51. }  
52.   
53. //以主动的方式记录日志  
54. void Logger::LogMsgActive(const string& msg)  
55. {  
56.     //生成命令对象，插入到命令队列中  
57.     cmdQueue.enqueue(new LogMsgCmd(this,msg));  
58. }  
59.   
60. int Logger::svc()  
61. {  
62.     while(true)  
63.     {  
64.         //遍历命令队列，执行命令  
65.         auto_ptr<ACE_Method_Object> mo  
66.             (this->cmdQueue.dequeue ());  
67.   
68.         if (mo->call () == -1)  
69.             break;  
70.     }  
71.     return 0;  
72. }  
73.   
74. int main (int argc, ACE_TCHAR *argv[])  
75. {  
76.     Logger log;  
77.     log. LogMsgActive ("hello");  
78.   
79.     ACE_OS::sleep(1);  
80.     log.LogMsgActive("abcd");  
81.   
82.     while(true)  
83.         ACE_OS::sleep(1);  
84.   
85.     return 0;  
86. }  

 

在这里需要注意一下命令队列ACE_Activation_Queue对象，它是线程安全的，使用方法比较简单，这里我也不多介绍了。

主动对象的基本结构就是这样，然而，由于主动对象是异步调用的，又引出了如下两个新问题：

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

这两个问题将在下回给与解决。