ACE笔记（6） Proactor机制下的异步SOCKET开发
Proactor机制和reactor机制的不同
1、在reactor机制下，所有I/O请求是同步的，即接到信号请求后，立即执行信号处理，
执行完后才开始继续监听信号请求，其接收信号请求的机制是被动的
而在Proactor机制下，I/O请求是异步的，即接到信号请求后，不立即执行信号处理（而是在莫个时刻执行该处理），
然后再继续监听信号请求，其接收信号请求的机制是主动的
2、要想符合Proactor机制的信号处理，需要从 ACE_Service_Handler 派生,而reactor机制信号处理类要从ACE_Event_Handler派生
ACE_Service_Handler 中以定义的常见回调方法：
/// 异步读完成时会被调用
virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
/// 在UDP SOCKET中，当异步写完成时会被调用
virtual void handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result);
/// 在UDP SOCKET中，当异步读完成时会被调用
virtual void handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result);
/// 当异步写完成时会被调用
virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
/// 当异步读文件完成时会被调用
virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result);
/// 当异步写文件完成时会被调用
virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result);
///当异步接收完成时会被调用
virtual void handle_accept (const ACE_Asynch_Accept::Result &result);
///当异步连接完成时会被调用
virtual void handle_connect (const ACE_Asynch_Connect::Result &result);
///当异步传输文件完成时会被调用
virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result);
///超时时会被调用
virtual void handle_time_out (const ACE_Time_Value &tv,
const void *act = 0);
ACE_Service_Handler 类OPEN方法使用注意：
方法定义：open (ACE_HANDLE handle,ACE_Message_Block &message_block)
当客户端连接时会触发此方法
message_block 参数附带了伴随客户端连接发送过来的消息块
所以在实现OPEN方法中，要注意判断message_block 参数是否附带了消息，如果附带了，如果不想改变现有的事件数据统一处理模式，则需要自己模拟一个读完成动作，如下：
if (message_block.length () != 0)
{
// 复制消息块(引用)
ACE_Message_Block &duplicate =*message_block.duplicate ();
// 伪装一个事件读完成对象
ACE_Asynch_Read_Stream_Result_Impl *fake_result =
ACE_Proactor::instance ()->create_asynch_read_stream_result (*this,
this->handle_,
duplicate,
initial_read_size,
0,
ACE_INVALID_HANDLE,
0,
0);
//移动写指针到未写入的位置，因为读完成动作中会自动移动写指针
size_t bytes_transferred = message_block.length ();
duplicate.wr_ptr (duplicate.wr_ptr () - bytes_transferred);
//发出事件完成回调命令
fake_result->complete (message_block.length (),
1,
0);
// 删除伪装的对象
delete fake_result;
}
ACE_Asynch_Read_Stream 类常见方法
open 方法：初始化读操作
read 方法：读操作，把数据存放在一个 ACE_Message_Block 数据结构上，该结构会自动移动写指针(wr_ptr)
ACE_Asynch_Write_Stream 类常见方法
open 方法：初始化写操作
write方法：写操作，会把存在 ACE_Message_Block 数据结构上写入指定的handle中,该结构会自动移动读指针(rd_ptr)
ACE_Message_Block 类常见方法
构造函数：ACE_Message_Block (长度)
rd_ptr()：返回读指针
wr_ptr(): 返回写指针
release():释放内存
init(data,len):分配内存
wr_ptr(len):把写指针向前移动LEN个位置
wr_ptr(×):把写指针指向当前指针
duplicate()：复制当前消息块
ACE_Asynch_Read_Stream::Result 类常见方法、属性
用于在回调完成时获得相关完成信息的类
bytes_to_read ()：想读取的字节数
bytes_transferred ()：有多少个字节被接收
handle ():作用在那个handle上
success（）：操作是否成功
message_block ()：返回消息块
下面附带一个异步I/O处理的例子(例子来源于ACE自带例子，稍有改动)，该例子用来异步接收客户请求，并把客户请求的信息显示在控制台上
#include "ace/OS_main.h"
#include "ace/Service_Config.h"
#include "ace/Proactor.h"
#include "ace/Asynch_IO.h"
#include "ace/Asynch_IO_Impl.h"
#include "ace/Asynch_Acceptor.h"
#include "ace/INET_Addr.h"
#include "ace/SOCK_Connector.h"
#include "ace/SOCK_Acceptor.h"
#include "ace/SOCK_Stream.h"
#include "ace/Message_Block.h"
#include "ace/Get_Opt.h"
#include "ace/OS_NS_sys_stat.h"
static u_short port = ACE_DEFAULT_SERVER_PORT;
static int done = 0;
static int initial_read_size = BUFSIZ;
class Receiver : public ACE_Service_Handler
{
public:
Receiver (void);
~Receiver (void);
virtual void open (ACE_HANDLE handle,
ACE_Message_Block &message_block);
protected:
virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result);
private:
int initiate_read_stream (void);
ACE_Asynch_Read_Stream rs_;
ACE_HANDLE handle_;
// Handle for IO to remote peer.
};
Receiver::Receiver (void)
: dump_file_ (ACE_INVALID_HANDLE),
handle_ (ACE_INVALID_HANDLE)
{}
Receiver::~Receiver (void){}
void
Receiver::open (ACE_HANDLE handle,
ACE_Message_Block &message_block)
{
ACE_DEBUG ((LM_DEBUG,
"%N:%l:Receiver::open called\n"));
this->handle_ = handle;
// 打开SOCKET读取流
if (this->rs_.open (*this, this->handle_) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Read_Stream::open"));
return;
}
if (message_block.length () != 0)
{
// 复制消息块(引用)
ACE_Message_Block &duplicate =*message_block.duplicate ();
// 伪装一个事件读完成对象
ACE_Asynch_Read_Stream_Result_Impl *fake_result =
ACE_Proactor::instance ()->create_asynch_read_stream_result (*this,
this->handle_,
duplicate,
initial_read_size,
0,
ACE_INVALID_HANDLE,
0,
0);
//移动写指针到未写入的位置，因为读完成动作中会自动移动写指针
size_t bytes_transferred = message_block.length ();
duplicate.wr_ptr (duplicate.wr_ptr () - bytes_transferred);
//发出事件完成回调命令
fake_result->complete (message_block.length (),
1,
0);
// 删除伪装的对象
delete fake_result;
}
else
// 没有附带数据，则开始一个新的读操作
if (this->initiate_read_stream () == -1)
return;
}
int
Receiver::initiate_read_stream (void)
{
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (BUFSIZ + 1),
-1);
// 开始读操作
if (this->rs_.read (*mb,
mb->size () - 1) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"ACE_Asynch_Read_Stream::read"),
-1);
return 0;
}
void
Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
//开始读操作
ACE_DEBUG ((LM_DEBUG,
"handle_read_stream called\n"));
//显示读取的信息
result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message:", result.message_block ().rd_ptr ()));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
if (result.success () && result.bytes_transferred () != 0)
{
result.message_block ().release();
// 如果还存在未读取数据，则继续读取
if (this->initiate_read_stream () == -1)
return;
}
else
{
//不存在，则释放消息块并关闭SOCKET连接
ACE_DEBUG ((LM_DEBUG,
"Receiver completed\n"));
result.message_block ().release ();
done = 0;
ACE_OS::closesocket (this->handle_);
}
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_Asynch_Acceptor<Receiver> acceptor;
//打开SOCKET端口
if (acceptor.open (ACE_INET_Addr (port),
initial_read_size,
1) == -1)
return -1;
int success = 1;
while (success > 0 && !done)
// 处理和分发事件
success = ACE_Proactor::instance ()->handle_events ();
return 0;
}
//下面的代码时帮助编译器解析上面的模板
#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
template class ACE_Asynch_Acceptor<Receiver>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#pragma instantiate ACE_Asynch_Acceptor<Receiver>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
