ACE前摄器Proactor模式

    当 OS 平台支持异步操作时，一种高效而方便的实现高性能 Web 服务器的方法是使用前摄式事件分派。使用前摄式事件分派模型设计的 Web 服务器通过一或多个线程控制来处理异步操作的完成。这样，通过集成完成事件多路分离（completion event demultiplexing）和事件处理器分派，前摄器模式简化了异步的 Web 服务器。

异步的 Web 服务器将这样来利用前摄器模式：首先让 Web 服务器向 OS 发出异步操作，并将回调方法登记到 Completion Dispatcher（完成分派器），后者将在操作完成时通知 Web 服务器。于是 OS 代表 Web 服务器执行操作，并随即在一个周知的地方将结果排队。Completion Dispatcher 负责使完成通知出队，并执行适当的、含有应用特有的 Web 服务器代码的回调。

使用前摄器模式的主要优点是可以启动多个并发操作，并可并行运行，而不要求应用必须拥有多个线程。操作被应用异步地启动，它们在 OS 的 I/O 子系统中运行直到完成。发起操作的线程现在可以服务 另外的请求了。

在ACE中，可以通过ACE_Proactor实现前摄器模式。实现方式如下。

1。创建服务处理器：

Proactor框架中服务处理器均派生自ACE_Service_Handler，它和Reactor框架的事件处理器非常类似。当发生IO操作完成事件时，会触发相应的事件完成会调函数。关键方法：

open(): 挂钩方法，用于在新连接建立之后初始化服务。

addressess():挂钩方法，用于捕捉服务连接的本地和远地地址。

handle(): 获取这个对象所用的句柄。

handle_read_stream():挂钩方法，在ACE_Asynch_Read_Stream发起的read()操作完成时调用。

handle_write_stream():挂钩方法，在ACE_Asynch_Write_Stream发起的write()操作完成时调用。

handle_time_out():挂钩方法，在通过ACE_Proactor调度的定时器到期时调用。

2。实现服务处理器IO操作

Proactor框架中所有的IO操作都由相应的异步操作类来完成，这些异步操作类都继承自ACE_Asynch_Operation。常用的有以下几种。

1. ACE_Asynch_Read_Stream, 提供从TCP/IP socket连接中进行异步读操作.
   关键方法：
   open():初始化对象，为发起异步read()操作做准备。
   cancel():尝试取消通过这个对象发起的未完成read()操作。
   read():发起异步操作，从相关联的IPC流中读取数据。
2. ACE_Asynch_Write_Stream, 提供从TCP/IP socket连接中进行异步写操作.
   关键方法：

   open():初始化对象，为发起异步write()操作做准备。

   cancel():尝试取消通过这个对象发起的未完成write()操作。

   read():发起异步操作，从相关联的IPC流中读取数据。

  3.ACE_Asynch_Result,对象关键方法：

success():指示异步操作是否成功。

handle():获取异步I/O操作所使用的I/O句柄。

message_block:获取指向“在操作中所使用的ACE_Message_Block”的引用。

bytes_transferred:指示在异步操作中实际传输了多少字节。

bytes_to_read():指示情趣read()操作读取的字节是多少。

bytes_to_write():指示情趣write()操作读取的字节是多少

使用这些操作类的一般方式如下：

1. 初始化
   将相关的操作注册到服务处理器中，一般可通过调用其open方法实现。
2. 发出IO操作
   发出异步IO操作请求，该操作不会阻塞，具体的IO操作过程由操作系统异步完成。
3. IO操作完成回调处理
   异步IO操作完成后，OS会触发服务处理器中的相应回调函数，可通过该函数的ACE_Asynch_Result参数获取相应的返回值。

3。使用连接器或接受器和远端进行连接

ACE为Proactor框架提供了两个工厂类来建立TCP/IP连接。

1. ACE_Asynch_Acceptor, 用于被动地建立连接，关键方法如下：
   open() : 初始化和发出一个或多个异步accept()操作。
   cancel() : 取消所有有该接收器发起的异步accept()操作。
   validate_connection() : 挂钩方法，用于在新连接打开服务之前确认对端地址。返回-1连接中断，0连接成功。
   make_handler()  : 挂钩方法，用于在新连接获取服务处理器对象。默认情况new  分配服务新的处理器。
   
   
2. ACE_Asynch_Connector 用于主动地建立连接，关键方法如下：

   open() :  初始化用于主动连接工厂的信息。

   connect(): 发起一个异步connect()操作。

   cancel() :  取消所有有异步connect()操作。

   validate_connection() : 挂钩方法，用于在新连接打开服务之前确认对端地址。返回-1连接中断，0连接成功。

   make_handler() : 挂钩方法，用于在新连接获取服务处理器对象。默认情况new  分配服务新的处理器。

   
   

当远端连接建立时，连接器或接受器便会创建相应的服务处理器，从而可以实现服务处理。

4。启动Proactor事件分发处理

关键方法如下：

handle_events(): 等待完成事件发生，并随即分派与其相关联的完成处理器。可以使用超时参数在限制花在等待时间上的时间。

  proactor_run_loop()： 反复调用handle_events()方法，直至发生下列情况之一，该方法失败、proator_event_loop_done()返回真或发生超时。

proactor_end_event_loop()：指示前摄器关闭其事件循环。

proator_event_loop_done()：如果前摄器的时间循环已被结束就返回1

启动事件分发处理只需如下调用：

    while(true)
        ACE_Proactor::instance ()->handle_events ();

5。程序示例

服务器端：

服务器端简单的实现了一个EchoServer，流程如下：

当客户端建立连接时，首先发出一个异步读的异步请求，当读完成时，将所读的数据打印出来，并发出一个新的异步请求。

Cpp代码  

1. #include "ace/Message_Queue.h"  
2. #include "ace/Asynch_IO.h"  
3. #include "ace/OS.h"  
4. #include "ace/Proactor.h"  
5. #include "ace/Asynch_Acceptor.h"  
6.   
7. class HA_Proactive_Service : public ACE_Service_Handler  
8. {  
9. public:  
10. ~HA_Proactive_Service ()  
11. {  
12. if (this->handle () != ACE_INVALID_HANDLE)  
13. ACE_OS::closesocket (this->handle ());  
14. }  
15.   
16. virtual void open (ACE_HANDLE h, ACE_Message_Block&)  
17. {  
18.      this->handle (h);  
19.      if (this->reader_.open (*this) != 0 )  
20.      {  
21.          ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),  
22.              ACE_TEXT ("HA_Proactive_Service open")));  
23.          delete this;  
24.          return;  
25.      }  
26.   
27.      ACE_Message_Block *mb = new ACE_Message_Block(buffer,1024);  
28.      if (this->reader_.read (*mb, mb->space ()) != 0)  
29.      {  
30.          ACE_OS::printf("Begin read fail\n");  
31.          delete this;  
32.          return;  
33.      }  
34.   
35.      return;  
36. }  

 

// 异步读完成后会调用此函数

Cpp代码  

1. virtual void handle_read_stream  
2. (const ACE_Asynch_Read_Stream::Result &result)  
3. {  
4.      ACE_Message_Block &mb = result.message_block ();  
5.      if (!result.success () || result.bytes_transferred () == 0)  
6.      {  
7.          mb.release ();  
8.          delete this;  
9.          return;  
10.      }  
11.   
12.      mb.copy("");    //为字符串添加结束标记'\0'  
13.      ACE_OS::printf("rev:\t%s\n",mb.rd_ptr());  
14.      mb.release();  
15.   
16.      ACE_Message_Block *nmb = new ACE_Message_Block(buffer,1024);  
17.      if (this->reader_.read (*nmb, nmb->space ()) != 0)  
18.   
19.      return;  
20. }  
21.   
22. private:  
23. ACE_Asynch_Read_Stream reader_;  
24. char buffer[1024];  
25. };  
26.   
27.   
28. int main(int argc, char *argv[])   
29. {  
30.     int port=3000;  
31.     ACE_Asynch_Acceptor<HA_Proactive_Service> acceptor;  
32.       
33.     if (acceptor.open (ACE_INET_Addr (port)) == -1)  
34.         return -1;  
35.   
36.     while(true)  
37.         ACE_Proactor::instance ()->handle_events ();  
38.       
39.     return 0;   
40. }  

 

客户端：

客户端代码比较简单，就是每隔1秒钟将当前的系统时间转换为字符串形式通过异步形式发送给服务器，发送完成后，释放时间字符的内存空间。

Cpp代码  

1. #include "ace/Message_Queue.h"  
2. #include "ace/Asynch_IO.h"  
3. #include "ace/OS.h"  
4. #include "ace/Proactor.h"  
5. #include "ace/Asynch_Connector.h"  
6.   
7. class HA_Proactive_Service : public ACE_Service_Handler  
8. {  
9. public:  
10. ~HA_Proactive_Service ()  
11. {  
12. if (this->handle () != ACE_INVALID_HANDLE)  
13. ACE_OS::closesocket (this->handle ());  
14. }  
15.   
16. virtual void open (ACE_HANDLE h, ACE_Message_Block&)  
17. {  
18.      this->handle (h);  
19.      if (this->writer_.open (*this) != 0 )  
20.      {  
21.          ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),  
22.              ACE_TEXT ("HA_Proactive_Service open")));  
23.          delete this;  
24.          return;  
25.      }  
26.   
27.      ACE_OS::printf("connceted");  
28.   
29.      for(int i=0;i<10;i++)    //每隔秒中发送时间至服务器  
30.      {  
31.          ACE_OS::sleep(1);  
32.          time_t now = ACE_OS::gettimeofday().sec();  
33.          char *time = ctime(&now);        //获取当前时间的字符串格式  
34.          ACE_Message_Block *mb = new ACE_Message_Block(100);  
35.          mb->copy(time);  
36.   
37.          if (this->writer_.write(*mb,mb->length()) !=0)  
38.          {  
39.              ACE_OS::printf("Begin read fail\n");  
40.              delete this;  
41.              return;  
42.          }  
43.      }  
44.   
45.      return;  
46. }  

 

// 异步写完成后会调用此函数

Cpp代码  

1. virtual void handle_write_dgram  
2. (const ACE_Asynch_Write_Stream::Result &result)  
3. {  
4.      ACE_Message_Block &mb = result.message_block ();  
5.      mb.release();  
6.      return;  
7. }  
8.   
9. private:  
10. ACE_Asynch_Write_Stream writer_;  
11. };  
12.   
13. int main(int argc, char *argv[])   
14. {  
15.       
16.     ACE_INET_Addr addr(3000,"192.168.1.142");   
17.   
18.     HA_Proactive_Service *client = new HA_Proactive_Service();  
19.     ACE_Asynch_Connector<HA_Proactive_Service> connector;  
20.       
21.     connector.open();  
22.     if (connector.connect(addr) == -1)  
23.         return -1;  
24.   
25.     while(true)  
26.         ACE_Proactor::instance ()->handle_events ();  
27.       
28.     return 0;   
29. }