ACE异步框架

转载：http://blog.csdn.net/jacklam200/article/details/3510968

当 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操作完成事件时，会触发相应的事件完成会调函数。

 

 

2

                    Proactor框架中的类

。实现服务处理器IO操作

 

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

 

ACE_Asynch_Read_Stream, 提供从TCP/IP socket连接中进行异步读操作I/O工厂类.

ACE_Asynch_Write_Stream, 提供从TCP/IP socket连接中进行异步写操作I/O工厂类..

Result，每个I/O工厂类都把Result定义为嵌在自己内部的类，用以保存该工厂发起的每个操作的结果，所有的Result类都从ACE_Asynch_Result派生，并且增加了专用于他们所针对的I/O类型的数据和方法。因为每个异步I/O操作的发起和完成都是分离的，不同的事件，我们需要有一种机制来“记住”操作的参数，并连同结果一起吧这些参数转交给完成处理器。

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

 

初始化

将相关的操作注册到服务处理器中，一般可通过调用其open方法实现。

发出IO操作

发出异步IO操作请求，该操作不会阻塞，具体的IO操作过程由操作系统异步完成。

IO操作完成回调处理

异步IO操作完成后，OS会触发服务处理器中的相应回调函数，可通过该函数的ACE_Asynch_Result参数获取相应的返回值。

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

 

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

 

ACE_Asynch_Acceptor, 用于被动地建立连接

ACE_Asynch_Connector 用于主动地建立连接

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

 

4。启动Proactor事件分发处理

 

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

 

    while(true)

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

 

5。程序示例

 

服务器端：

 

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

 

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

 

1. #include <iostream>
2. #include "ace/Message_Queue.h"
4. #include "ace/Asynch_IO.h"
6. #include "ace/OS.h"
8. #include "ace/Proactor.h"
10. #include "ace/Asynch_Acceptor.h"
12. using namespace std;
13. class HA_Proactive_Service : public ACE_Service_Handler
14. {
16. public:
17.     ~HA_Proactive_Service ()
18.     {
19.         if (this->handle () != ACE_INVALID_HANDLE)
20.             ACE_OS::closesocket (this->handle ());
21.     }
24.     virtual void open (ACE_HANDLE h, ACE_Message_Block&)
25.     {
26.         this->handle (h);
27.         this->handle(h);
28.         if(this->reader_.open(*this)!=0||this->writer_.open(*this)!=0)
29.         {
30.             ACE_ERROR((LM_ERROR,ACE_TEXT("%p/n"),ACE_TEXT("HA_Proactive_Service open")));
31.             delete this;
32.             return;
33.         }
34.         ACE_Message_Block *mb;
35.         ACE_NEW_NORETURN(mb,ACE_Message_Block(1024));
36.         if(this->reader_.read(*mb,mb->space())!=0)
37.         {
38.             ACE_ERROR((LM_ERROR,ACE_TEXT("%p/n"),ACE_TEXT("HA_Proactive_Service begin read")));
39.             mb->release();
40.             delete this;
41.             return ;
42.         }
43.         return;
44.     }
48.     //异步读完成后会调用此函数
50.     virtual void handle_read_stream(const ACE_Asynch_Read_Stream::Result &result)
51.     {
53.         ACE_Message_Block &mb=result.message_block();
54.         if(!result.success()||result.bytes_transferred()==0)
55.         {
56.             mb.release();
57.             delete this;
58.         }
59.         else
60.         {
61.             if((this->writer_.write(mb,mb.length()))!=0)
62.             {
63.                 ACE_ERROR((LM_ERROR,ACE_TEXT("%p/n"),ACE_TEXT("starting write")));
64.                 mb.release();
65.             }
66.             else
67.             {
68.                 ACE_Message_Block *new_mb;
69.                 ACE_NEW_NORETURN(new_mb,ACE_Message_Block(1024));
70.                 this->reader_.read(*new_mb,new_mb->space());
71.             }
72.         }
73.         return ;
75.     }
76.     virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
77.     {
79.         result.message_block().release();
80.         return ;
81.     }
82. private:
83.     ACE_Asynch_Read_Stream reader_;
84.     ACE_Asynch_Write_Stream writer_;
85. };
91. int main(int argc, char *argv[]) 
92. {
93.     int port=3000;
94.     ACE_Asynch_Acceptor<HA_Proactive_Service> acceptor;
95.     if (acceptor.open (ACE_INET_Addr (port)) == -1)
96.         return -1;
97.     while(true)
98.         ACE_Proactor::instance ()->handle_events ();
99.     return 0; 
100. } 

客户端：

 

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

 

  

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. #include <iostream>
7. using namespace std;
9. class HA_Proactive_Service : public ACE_Service_Handler
10. {
11. public:
12.     ~HA_Proactive_Service ()
13.     {
14.         if (this->handle () != ACE_INVALID_HANDLE)
15.             ACE_OS::closesocket (this->handle ());
16.     }
17.     virtual void open (ACE_HANDLE h, ACE_Message_Block&)
18.     {
19.         this->handle (h);
20.         if (this->writer_.open (*this) != 0 )
21.         {
22.             ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p/n"),
23.                 ACE_TEXT ("HA_Proactive_Service open")));
24.             delete this;
25.             return;
26.         }
27.         ACE_OS::printf("connceted");
28.         for(int i=0;i<10;i++)    //每隔秒中发送时间至服务器
29.         {
30.             ACE_OS::sleep(1);
31.             time_t now = ACE_OS::gettimeofday().sec();
32.             char *time = ctime(&now);        //获取当前时间的字符串格式
33.             ACE_Message_Block *mb = new ACE_Message_Block(100);
34.             mb->copy(time);
35.             if (this->writer_.write(*mb,mb->length()) !=0)
36.             {
37.                 ACE_OS::printf("Begin read fail/n");
38.                 delete this;
39.                 return;
41.             }
42.         }
43.         return;
44.     }
45.     //异步写完成后会调用此函数
47.     virtual void handle_write_dgram(const ACE_Asynch_Write_Stream::Result &result)
48.     {
49.         ACE_Message_Block &mb = result.message_block ();
50.         mb.release();
51.         return;
53.     }
54. private:
55.     ACE_Asynch_Write_Stream writer_;
56. };
60. int main(int argc, char *argv[]) 
61. {
62.     ACE_INET_Addr addr(3000,"192.168.142.181"); 
63.     HA_Proactive_Service *client = new HA_Proactive_Service();
64.     ACE_Asynch_Connector<HA_Proactive_Service> connector;
65.     connector.open();
66.     if (connector.connect(addr) == -1)
67.         return -1;
68.     while(true)
69.         ACE_Proactor::instance ()->handle_events ();
70.     return 0; 
71. }