前摄器模式

最新推荐文章于 2017-08-13 18:30:00 发布
最新推荐文章于 2017-08-13 18:30:00 发布
阅读量511 收藏
点赞数
文章标签： service stream 服务器 os delete buffer

当 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。实现服务处理器IO操作

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

  1. ACE_Asynch_Read_Stream, 提供从TCP/IP socket连接中进行异步读操作.
  2. ACE_Asynch_Write_Stream, 提供从TCP/IP socket连接中进行异步写操作.

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

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

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

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

  1. ACE_Asynch_Acceptor, 用于被动地建立连接
  2. ACE_Asynch_Connector 用于主动地建立连接

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

4。启动Proactor事件分发处理

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

    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. }  
#include "ace/Message_Queue.h"
#include "ace/Asynch_IO.h"
#include "ace/OS.h"
#include "ace/Proactor.h"
#include "ace/Asynch_Acceptor.h"

class HA_Proactive_Service : public ACE_Service_Handler
{
public:
~HA_Proactive_Service ()
{
if (this->handle () != ACE_INVALID_HANDLE)
ACE_OS::closesocket (this->handle ());
}

virtual void open (ACE_HANDLE h, ACE_Message_Block&)
{
     this->handle (h);
     if (this->reader_.open (*this) != 0 )
     {
         ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
             ACE_TEXT ("HA_Proactive_Service open")));
         delete this;
         return;
     }

     ACE_Message_Block *mb = new ACE_Message_Block(buffer,1024);
     if (this->reader_.read (*mb, mb->space ()) != 0)
     {
         ACE_OS::printf("Begin read fail\n");
         delete this;
         return;
     }

     return;
}
 

// 异步读完成后会调用此函数
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. }  
virtual void handle_read_stream
(const ACE_Asynch_Read_Stream::Result &result)
{
     ACE_Message_Block &mb = result.message_block ();
     if (!result.success () || result.bytes_transferred () == 0)
     {
         mb.release ();
         delete this;
         return;
     }

     mb.copy("");    //为字符串添加结束标记'\0'
     ACE_OS::printf("rev:\t%s\n",mb.rd_ptr());
     mb.release();

     ACE_Message_Block *nmb = new ACE_Message_Block(buffer,1024);
     if (this->reader_.read (*nmb, nmb->space ()) != 0)

     return;
}

private:
ACE_Asynch_Read_Stream reader_;
char buffer[1024];
};


int main(int argc, char *argv[]) 
{
    int port=3000;
    ACE_Asynch_Acceptor<HA_Proactive_Service> acceptor;
    
    if (acceptor.open (ACE_INET_Addr (port)) == -1)
        return -1;

    while(true)
        ACE_Proactor::instance ()->handle_events ();
    
    return 0; 
}
 

客户端：

客户端代码比较简单，就是每隔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. }  
#include "ace/Message_Queue.h"
#include "ace/Asynch_IO.h"
#include "ace/OS.h"
#include "ace/Proactor.h"
#include "ace/Asynch_Connector.h"

class HA_Proactive_Service : public ACE_Service_Handler
{
public:
~HA_Proactive_Service ()
{
if (this->handle () != ACE_INVALID_HANDLE)
ACE_OS::closesocket (this->handle ());
}

virtual void open (ACE_HANDLE h, ACE_Message_Block&)
{
     this->handle (h);
     if (this->writer_.open (*this) != 0 )
     {
         ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
             ACE_TEXT ("HA_Proactive_Service open")));
         delete this;
         return;
     }

     ACE_OS::printf("connceted");

     for(int i=0;i<10;i++)    //每隔秒中发送时间至服务器
     {
         ACE_OS::sleep(1);
         time_t now = ACE_OS::gettimeofday().sec();
         char *time = ctime(&now);        //获取当前时间的字符串格式
         ACE_Message_Block *mb = new ACE_Message_Block(100);
         mb->copy(time);

         if (this->writer_.write(*mb,mb->length()) !=0)
         {
             ACE_OS::printf("Begin read fail\n");
             delete this;
             return;
         }
     }

     return;
}
 

// 异步写完成后会调用此函数
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. } 


mopname
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ACE学习（十）前摄器模式
胜利者的经验并不复杂,那就是寻找人生的关键点,并在关键时刻竭尽全力
06-21 3569
前摄器模式 1.前摄器的原理 前摄器模式是充分使用了操作系统的支持异步I/O的特性，使用异步来代替多线程并发，因为多线程并发会带来很多性能的开销（创建、切换、同步等），而异步像更加底层的操作系统操作，性能是相对较高（为什么？待补充）   2.前摄器的优点 “与传统的反应式或同步式I/O模型不同，前摄式模型允许每个应用线程同时发起多个操作。这一设计允许单线程化应用并发地执行多个I/
Windows下采用IOCP实现的ACE的Proactor框架剖析
04-20
ACE的Proactor框架在Windows底层下是采用IOCP来实现的，这里采用IOCP模仿实现了ACE的Proactor框架，对于学习和研究ACE的Proactor框架很有帮助.
ACE前摄器Proactor模式
weixin_34261415的博客
12-31 135
 当 OS 平台支持异步操作时，一种高效而方便的实现高性能 Web 服务器的方法是使用前摄式事件分派。使用前摄式事件分派模型设计的 Web 服务器通过一或多个线程控制来处理异步操作的完成。这样，通过集成完成事件多路分离（completion event demultiplexing）和事件处理器分派，前摄器模式简化了异步的 Web 服务器。 异步的 Web 服务器将这样来利用前摄器模式：首先...
设计模式-前摄器模式(Proactor)
weixin_33805557的博客
08-13 194
本周要进行boost asio库的学习，在学习之前发现最好需要先了解一下前摄器模式，这样对asio库的理解很有帮助，故写下此文 我之前写的随笔XShell的模拟实现中的链接方式可以说是同步的（服务器阻塞等待链接），这样当有服务器端在等待链接的时候就浪费了大量的资源，我们可以让服务器异步等待客户端的链接，服务器在等待链接的同时可以做别的事情，等到客户端链接请求到来的时候，调用一个回调执行链接，这就...
前摄器模式学习笔记
weixin_34343689的博客
04-10 217
声明：学习资料是：http://docs.huihoo.com/ace_tao/ACE-2002-12/Part-One/Chapter-8.htm(后面会给出原文) ·概要： 接触前摄器模式是在学习BOOST.ASIO时看到的—BOOST.ASIO内部是采用的前摄器模式实现的，为了深入理解BOOST.ASIO才学习一下前摄器模式。 同时采用前摄器模式的应用还有windo...
ACE的前摄器模式笔记
rogone的专栏
07-22 888
ACE的前摄器模式笔记ACE的代码组织ACE的前摄器模式中，包括前摄器接口，类命名会有如下形式代码关系class A { A_Impl* implement; }class A_Impl { }class WIN32_A : public A_Impl { }调用A的接口将直接调用指针成员A_Imp的同名接口（A_Impl仍然是接口），实际上调用了WIN32_A 对象中的实现。 因为前摄器功能的实
摄色器、吸色器
08-20
"摄色器"和"吸色器"，也被称为"采色器"或"采色工具"，是用来从屏幕上精确获取颜色值的软件工具。这些工具对于设计师、前端开发者、UI/UX专业人士以及其他需要精确匹配颜色的人来说极其重要。 ColorCop是一款广受...
相机拍摄模式新手指南.docx
09-27
使用微距镜头能得到最佳效果，如果没有，也可以利用长焦端进行近摄。 4. 运动模式：针对快速移动的物体，运动模式会使用中央对焦点进行连续对焦，并提高ISO感光度以保证快门速度，冻结运动瞬间。同时，它启用连拍...
镜头反应拍摄模式初探.doc
05-04
- 技巧性拍摄：适时调整拍摄角度、距离和时机，减少被摄对象的不适感，同时确保新闻素材的完整性。 - 法律保障：在遭遇抗拒式反应时，摄像记者应熟知自身权益，必要时寻求法律保护。 在不同类型的新闻报道中，如...
inav飞行模式
12-20
iNav飞行控制系统通过不同的飞行模式，实现了飞行器在不同环境下的稳定控制和复杂任务的自动化执行。这些模式不仅涵盖了基础的飞行控制需求，还包含了高级特性如自动返航、航点导航等。 #### 实际飞行模式解析 1. ...
ACE前摄器TProactor
04-13
ACE前摄器TProactor 及AIO
使用ACE_Proactor模式，在使用ACE_Asynch_Write_Stream.write发送数据的问题
思者无域，行者无疆
09-25 334
1. 使用ACE_Proactor模式，客户端实现代码如下： [code="c++"] void TClientHandler::open(ACE_HANDLE handle, ACE_Message_Block &msgBlock) { this->handle(handle); int size = 0; int buf_len = size...
异步I/O与ACE Proactor框架
编程菜鸟---正在努力进阶
12-13 3100
当 OS 平台支持异步操作时，一种高效而方便的实现高性能 Web 服务器的方法是使用前摄式事件分派。使用前摄式事件分派模型设计的 Web 服务器通过一或多个线程控制来处理异步操作的完成。这样，通过集成完成事件多路分离（completion event demultiplexing）和事件处理器分派，前摄器模式简化了异步的 Web 服务器。  异步的 Web 服务器将这样来利用前摄器模式：首
ACE中的Proactor介绍和应用实例
roger007的专栏
04-07 5362
   把这两天做Proactor的一些经验和心得写一下，可能会给一些人帮助。    Proactor是异步模式的网络处理器，ACE中叫做“前摄器”。    先讲几个概念：    前摄器（Proactor）－异步的事件多路分离器、处理器，是核心处理类。启动后由3个线程组成（你不需要关心这三个线程，我只是让你知道一下有这回事存在）。    接受器（Acceptor）－用于服务端，监听在一个端口上，接受
ACE通信框架的一些例子(包括MFC)
Stone_Sky
04-25 1826
原文地址：http://blog.csdn.net/zhjb1025/article/details/4017001 被ACE折磨了几天以后整理出来的一些经验，和大家分享 一.              ace的编译安装 环境：XP，VC6.0+SP6，ACE5.4 1.    解压缩ace源代码包，假设在D:/ACE_wrappers 2.    使用vc打开D:/ACE_wrappe
快速理解ace库以及它是如何包装完成端口的
ghosthjt的专栏
06-08 2095
符号说明 =>表示有这个成员 ->表示有这些子类 . 表示类的成员 ==>表示调用 -->接着调用 R_N 重复N次 1.ACE采用了声明和实现分离的方式，来完成各个模块，并且实现这个模式中的统一思想为：包装类 => 实现类的基类 -> 各具体实现类． 要想很好的看懂ace的代码，理解这个模式是很重要的，因为通常需要定位到具体的实现类上去看源代码，以下列出了ACE几个核心的类的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值