ACE学习（十）前摄器模式
前摄器模式
1.前摄器的原理
前摄器模式是充分使用了操作系统的支持异步I/O的特性，使用异步来代替多线程并发，因为多线程并发会带来很多性能的开销（创建、切换、同步等），而异步像更加底层的操作系统操作，性能是相对较高（为什么？待补充）
2.前摄器的优点
“与传统的反应式或同步式I/O模型不同，前摄式模型允许每个应用线程同时发起多个操作。这一设计允许单线程化应用并发地执行多个I/O操作，并且不会带来与传统的多线程化机制相关联的开销或设计复杂性”
“使用前摄器模式的主要优点是可以启动多个并发操作，并可并行运行，而不要求应用必须拥有多个线程。操作被应用异步地启动，它们在OS的I/O子系统中运行直到完成。发起操作的线程现在可以服务另外的请求了。
Completion Dispatcher可以是单线程的。当HTTP请求到达时，单个Completion Dispatcher线程解析请求，读取文件，并发送响应给客户。因为响应是被异步发送的，多个响应就有可能同时被发送。而且，同步的文件读取可以被异步的文件读取取代，以进一步增加并发的潜力。如果文件读取是被异步完成的，HTTP Handler所执行的唯一的同步操作就只剩下了HTTP协议请求解析。
前摄式模型的主要缺点是编程逻辑至少和反应式模型一样复杂。而且，前摄器模式可能会难以调试，因为异步操作常常有着不可预测和不可重复的执行序列，这就使分析和调试复杂化了。”
3.类介绍：
ACE_Service_Handler
/**
* @class ACE_Service_Handler
*
* @brief This base class defines the interface for the
* ACE_Asynch_Acceptor to call into when new connection are
* accepted.
*
* Subclasses of this class will fill in appropriate methods to
* define application specific behavior.
*/
这个是创建服务器 处理器的必须的目标类。此类中的open()挂钩方法会在新连接建立时被调用。
ACE_Asynch_Read_Stream
/**
* @class ACE_Asynch_Read_Stream
*
* @brief This class is a factory for starting off asynchronous reads
* on a stream. This class forwards all methods to its
* implementation class.
*
* Once {open} is called, multiple asynchronous {read}s can
* started using this class. An ACE_Asynch_Read_Stream::Result
* will be passed back to the {handler} when the asynchronous
* reads completes through the {ACE_Handler::handle_read_stream}
* callback.
*/
这个为在已链接的socket上发起异步读的工厂类。
Result
/**
* @class Result
*
* @brief This is the class which will be passed back to the
* {handler} when the asynchronous read completes. This class
* forwards all the methods to the implementation classes.
*
* This class has all the information necessary for the
* {handler} to uniquiely identify the completion of the
* asynchronous read.
*/
每个I/O工厂类都把Result定义为嵌在自己内部的类，用以保存改工厂发起的每个操作的结果。
4.代码分析，时间服务器回显的服务器代码如下：
#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&)
{
// handle方法是从ACE_Service_Handler的父类ACE_Handler继承而得
// 这个方法为hook方法，在新建立连接的时候被调用
// 这个方法会保存新的socket句柄
this->handle (h);
// 在保存完socket以后，必须用open初始化I/O工厂对象reader_，为发起I/O做准备
/**这个是open方法的参数与注释
* Initializes the factory with information which will be used with
* each asynchronous call.
*
* @arg handler The ACE_Handler that will be called to handle completions
* for operations initiated using this factory.
* @arg handle The handle that future read operations will use.
* If handle == @c ACE_INVALID_HANDLE,
* ACE_Handler::handle() will be called on @ handler
* to get the correct handle.
*
* @retval 0 for success.
* @retval -1 for failure; consult @c errno for further information.
*/
// int open (ACE_Handler &handler,
// ACE_HANDLE handle = ACE_INVALID_HANDLE,
// const void *completion_key = 0,
// ACE_Proactor *proactor = 0);
// 其中，第一个参数表示工厂操作的完成处理器，当完成I/O操作的时候Proactor框架会
// 回调这个对象，这也是处理器叫做完成处理器的原因
// ACE_Service_Handler是ACE_Handler的后代，即是读操作也是写操作的完成处理器所以
// *this被用作处理器的参数
// 没有句柄传入，I/O工厂会调用ACE_Service_Handler::handler()方法来取得ACE_HANDLE
// ACE_Proactor也是默认的，使用的为一个进程范围内的一个ACE_Proactor对象
// 开始这里写错成&&，而&&第一部分是真的话不会进行下一部分判断也就是写工厂没有初始化
if ((this->reader_.open (*this) != 0) || (this->writer_.open(*this) != 0))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("HA_Proactive_Service open")));
delete this;
}
// open方法的最后一件事情就是调用I/O对象的read()方法来在socket上发起一个异步读操作
ACE_Message_Block *mb;
ACE_NEW_NORETURN(mb, ACE_Message_Block(1024));
if (this->reader_.read (*mb, mb->space ()) != 0)
{
ACE_OS::printf("Begin read fail\n");
delete this;
}
}
// 异步读完成后会调用此函数，此函数为ACE_Handler中的接口
// result为为I/O工厂的类对象，用于保存读取的结果
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;
}
else
{
// 为字符串添加结束标记'\0'并打印出来
ACE_OS::printf("rev:\t%s\n",mb.rd_ptr());
// 给客户端写回时间
time_t now = ACE_OS::gettimeofday().sec();
char *time = ctime(&now); //获取当前时间的字符串格式
mb.copy(time);
ACE_OS::printf(mb.rd_ptr());
if (this->writer_.write(mb, mb.length()) !=0)
{
ACE_OS::printf("Begin write fail\n");
mb.release();
}
else
{
// 发起一个新的读操作（上面open方法的最后一件事情）
ACE_Message_Block *nmb;
ACE_NEW_NORETURN(nmb, ACE_Message_Block(1024));
this->reader_.read (*nmb, nmb->space ());
}
}
}
virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
{
result.message_block().release();
}
private:
ACE_Asynch_Read_Stream reader_;
ACE_Asynch_Write_Stream writer_;
};
int ACE_TMAIN(int, ACE_TCHAR *[])
{
int port=3000;
ACE_Asynch_Acceptor<HA_Proactive_Service> acceptor;
/**
* @c open starts one or more asynchronous accept requests on a
* @a address. Each accept operation may optionally read an
* initial buffer from the new connection when accepted.
*/
// 初始化接收器对象，并开始接受连接
// 不是上面提到的任何一个方法
if (acceptor.open (ACE_INET_Addr (port)) == -1)
return -1;
// while(true)
// ACE_Proactor::instance ()->handle_events ();
// 或者
ACE_Proactor::instance()->proactor_run_event_loop();
return 0;
}
客户端代码如下：
// client.cpp
#include <iostream>
using namespace std;
#include "ace/INET_Addr.h"
#include "ace/SOCK_Stream.h"
#include "ace/SOCK_Connector.h"
#include "ace/Log_Msg.h"
#include "common/MD5.h"
int ACE_TMAIN(int, ACE_TCHAR *[])
{
ACE_INET_Addr srvr(3000, ACE_LOCALHOST);
ACE_SOCK_Connector connector;
ACE_SOCK_Stream peer;
if(-1 == connector.connect(peer, srvr))
{
ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("connect")), 1);
}
int bc;
char buf[64];
for (int i=0; i<10; ++i)
{
peer.send_n("uptime\n", 7);
bc = peer.recv(buf, sizeof(buf));
write(1, buf, bc);
ACE_OS::sleep(1);
}
peer.close();
return 0;
}
http://docs.huihoo.com/ace_tao/ACE-2002-12/Part-One/Chapter-8.htm
http://www.cnblogs.com/TianFang/archive/2006/12/31/608952.html
http://blog.csdn.net/jackie_zhang/article/details/4533728