ACE中的Proactor介绍和应用实例

把这两天做Proactor的一些经验和心得写一下，可能会给一些人帮助。
    Proactor是异步模式的网络处理器，ACE中叫做“前摄器”。
    先讲几个概念：
    前摄器（Proactor）－异步的事件多路分离器、处理器，是核心处理类。启动后由3个线程组成（你不需要关心这三个线程，我只是让你知道一下有这回事存在）。
    接受器（Acceptor）－用于服务端，监听在一个端口上，接受用户的请求。
    连接器（Connector）－用于客户端，去连接远程的监听。当然，如果远程是ACE写的，就是Acceptor。
    异步模式－即非阻塞模式。网络的传输速度一般来讲为10Mbps、100Mbps、1000Mbps。拿千兆网来说，实际的传输速度为1000Mbps/8大概为128KB左右。我们的CPU一般为P4 3.0GHZ，如果是32位的处理器，一秒钟大概可以处理6G的字节，那么，128KB的网络速度是远远及不上处理器的速度的。网络发送数据是一位一位发送出去的，如果CPU等在这里，发送完成函数才结束，那么，处理器浪费了大量时间在网络传输上。
    操作系统提供了异步的模式来传输网络数据，工作模式即：应用程序把要发送的数据交给操作系统，操作系统把数据放在系统缓冲区后就告诉应用程序OK了，我帮你发，应用程序该干嘛干嘛去。操作系统发送完成后，会给应用系统一个回执，告诉应用程序：刚才那个包发送完成了！
   举个例子：你有几封邮件和包裹要发，最有效率的办法是什么？你把邮件和包裹及交给总台，总台MM说，好了，你帮你发，你忙去吧！然后你去工作了。过了一会，总台MM打电话告诉你：“刚才我叫快递公司的人来了，把你的包裹发出去了。邮局的人也来了，取走了邮件，放心好了”。同样，如果你知道今天会有包裹来，比如你在淘宝上购物了，你能成天等在总台？你应该告诉总台MM：“今天可能有我的一个快递，你帮我收一下，晚上请你肯德基！”。MM：“看在肯得基的面子上，帮你收了”。某个时间，MM打电话来了：“帅哥，你的包裹到了，我帮你签收了，快来拿吧。”
   因为操作系统是很有效率的，所有，他在后台收发是很快的。应用程序也很简单。Proactor就是这种异步模式的。Proactor就是总台MM；ACE_Service_Handle就是总台代为收发邮件的公司流程。

我们看一个实例：

//***********************************************************
class TPTCPAsynchServerImpl : public ACE_Service_Handler
{
public:
 TPTCPAsynchServerImpl(void);
 ~TPTCPAsynchServerImpl(void);

 virtual void open (ACE_HANDLE handle, ACE_Message_Block &message_block); 
 virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);

 virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);

 virtual void  handle_time_out (const ACE_Time_Value &tv, const void *act=0);

private:
 int initiate_read_stream (const ACE_Asynch_Read_Stream::Result &result);

 ACE_Asynch_Read_Stream rs_;
 ACE_Asynch_Write_Stream ws_;

};

这个例子从ACE_Service_Handler继承过来，ACE_Service_Handle主要就是定义了一些回调函数。
1、 virtual void open (ACE_HANDLE handle, ACE_Message_Block &message_block);
  当有客户端连接上来，连接建立成功后Proactor会调用这个方法。

2、 virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
当用户要读的数据读好了后，调用这个方法

3、virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
当用户要写的数据在网卡上发送成功后，Proactor会回调这个方法

4、 virtual void  handle_time_out (const ACE_Time_Value &tv, const void *act=0);
当用户设定的时钟到期了，这个方法会被调用。

这跟和总台MM的联络方法是不是一样的？

对还缺点东西，缺少怎么向总台MM交待任务的方法。下面看看：

首先，创建一个监听器。

 ACE_Asynch_Acceptor<TPTCPAsynchServerImpl> acceptor_;
看到没，就是我们刚才写的类，因为他继承了回调接口，并实现了自已的代码，模板中ACE_Asynch_Acceptor会在合适的时候回调这些方法。

//创建一个地址对象
 ACE_INET_Addr addr(port, ip);
acceptor_.open (addr, 8 * 1024, 1);
    Open后，就开始监听了。其它的，向Proactor注册一些事件的事模板类中都替你做了，你不需要做很多事。
    那么，已经开始监听了，我的程序从哪里开始呢？对于一个服务程序来讲，程序是被用户的连接驱动的，一个用户程序想和通讯，必须先创建连接，就是Socket中的connect操作。这个操作Proactor会替我们做一些工作，当连接创建完成后，上面讲的Open方法会被调用，我们看看Open方法中都有些什么代码：

void TPTCPAsynchServerImpl::open (ACE_HANDLE handle, ACE_Message_Block &message_block)
{
 ACE_DEBUG ((LM_DEBUG, "%N:%l:TPTCPAsynchServerImpl::open()... "));

 //构造读流
 if (rs_.open (*this, handle) == -1)
 {
  ACE_ERROR ((LM_ERROR, "%N:%l: ", "TPTCPAsynchServerImpl::open() Error"));
  return;
    }

 //构造写流
 if (ws_.open(*this, handle) == -1)
 {
  ACE_ERROR ((LM_ERROR, "%N:%l: ", "TPTCPAsynchServerImpl::open() Error"));
  return;
    }

 //获取客户端连接地址和端口
 ACE_INET_Addr addr; 
 ACE_SOCK_SEQPACK_Association ass=ACE_SOCK_SEQPACK_Association(handle); 
 size_t addr_size=1; 
 ass.get_local_addrs(&addr,addr_size);

 this->server_->onClientConnect((int)handle, addr.get_ip_address(), addr.get_port_number());

 

 //如果客户连接时同时提交了数据，需要伪造一个结果，然后呼叫读事件
 if (message_block.length () != 0)
 {
 // ACE_DEBUG((LM_DEBUG, "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->proxy (),
                                                                     this->handle_,
                                                                     duplicate,
                                                                     1024,
                                                                     0,
                                                                     ACE_INVALID_HANDLE,
                                                                     0,
                                                                     0);

  size_t bytes_transferred = message_block.length ();

  // Accept事件处理完成，wr_ptr指针会被向前移动，将其移动到开始位置
  duplicate.wr_ptr (duplicate.wr_ptr () - bytes_transferred);

  // 这个方法将调用回调函数
  fake_result->complete (message_block.length (), 1, 0);

  // 销毁伪造的读结果
  delete fake_result;
 }

 // 否则，通知底层，准备读取用户数据
 //创建一个消息块。这个消息块将用于从套接字中异步读 
 ACE_Message_Block *mb = 0;
  ACE_NEW (mb, ACE_Message_Block (_bufSize));

 if (rs_.read (*mb, mb->size () - 1) == -1)
 {
  delete mb;
  ACE_ERROR ((LM_ERROR, "%N:%l:open init read failed!"));
  return;
 }
}

 

我们看到，首先创建了两个流，就是前面类定义中定义的一个异步写流，一个异步读流。以后对网络的读和写就通过这两个流进行。我还给出了一段读客户端地址和端口的代码。然后是读取客户Connect可能附带的数据，那段代码不用看懂，以后使用照抄就行。然后就是

 if (rs_.read (*mb, mb->size () - 1) == -1)
 {
  delete mb;
  ACE_ERROR ((LM_ERROR, "%N:%l:open init read failed!"));
  return;
 }

这段代码使用读流读一段数据。这段代码就是向总台MM交待：我要收包裹，收好了叫我！
也就是说，这段代码99%的可能是读不出数据的，只是向Proactor注册读的事件，具体的等待、读取操作由Proactor读，读到了，就回调Handle_Read_Stream方法。ACE_Message_Block是消息块，数据就是存放在消息块中的。
下面看看Handle_Read_Stream方法的代码：

void TPTCPAsynchServerImpl::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
 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, "********************/n"));

 result.message_block().release();

 if (this->initiate_read_stream (result) == -1)
 {
  ACE_ERROR((LM_ERROR, "%N:%l:read stream failed!connection closed, remove it:%d/n", result.handle()));
  closeConnection(result.handle());
 } 
}

 

这个函数被调用，就表明有数据已经读好了，包裹已经在总台了。Proactor比总台MM还好，给你送上门了，数据就在Result里，上面演示了Result中的数据。然后把消息块释放了，然后调用initiate_read_stream继续监听网络上可能到来的数据。看看initiate_read_stream好了：

int TPTCPAsynchServerImpl::initiate_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
 ACE_DEBUG((LM_TRACE, "%N:%l:TPTCPAsynchServerImpl::initiate_read_stream() "));
 //创建一个消息块。这个消息块将用于从套接字中异步读 
 ACE_Message_Block *mb = new ACE_Message_Block(_bufSize);
 if (mb == NULL)
 {
  ACE_DEBUG((LM_ERROR, "%N:%l:can't allock ACE_Message_Block.  ")); 
  return -1;
 }
 

 if (rs_.read (*mb, mb->size () - 1) == -1)
 {
  delete mb;
  ACE_ERROR_RETURN ((LM_ERROR, "%N:%l:rs->read() failed, clientID=%d ", result.handle()),  -1);
 }

 return 0;
}

 

代码很简单，就是创建一个新的消息块，然后使用读流注册一个读消息就可以了。

到此为止，Proactor的读流程很清楚了吧？

下面再说一个写流程。

写流程其实更简单，在任意想向客户端写数据的地方，调用相应代码就行了，比如，我们提供了SendData方法来发送数据，在任意想发送数据的地方调用SendData就行了，SendData的代码如下：

int TPTCPAsynchServerImpl::sendData(int clientID, const char *data, int dataLen, unsigned int &id)
{
 ACE_DEBUG((LM_DEBUG, "TPTCPAsynchServerImpl::sendData(void) "));

 ACE_Message_Block *mb; 
 ACE_NEW_RETURN(mb, ACE_Message_Block(dataLen + 1), -1);

 mb->wr_ptr((char*)data);                  
 ACE_OS::memcpy(mb->base(),(char*)data, dataLen);

 id = GlobleSingleton::instance()->getIndex();
 mb->msg_type((int)id);

 //向操作系统发送数据
 if (connection->ws->write (*mb , dataLen ) == -1)
 {
  ACE_ERROR_RETURN((LM_ERROR, "%N:%l:sendData failed! clientID=%d ", clientID),-1);
 }

 return 0;
}

 

简单说，就是创建了一个消息块，把用户数据拷贝进来，然后调用写流WS向Proactor发送一个Write事件就可以了，发送成功后，Handle_write_handle会被调用，看一下：

void
TPTCPAsynchServerImpl::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
  ACE_DEBUG ((LM_DEBUG,
              "handle_write_stream called "));

  // Reset pointers.
  result.message_block ().rd_ptr (result.message_block ().rd_ptr () - result.bytes_transferred ());

  ACE_DEBUG ((LM_DEBUG, "******************** "));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "bytes_to_write", result.bytes_to_write ()));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "handle", result.handle ()));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "bytes_transfered", result.bytes_transferred ()));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "act", (u_long) result.act ()));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "success", result.success ()));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "completion_key", (u_long) result.completion_key ()));
  ACE_DEBUG ((LM_DEBUG, "%s = %d ", "error", result.error ()));
  ACE_DEBUG ((LM_DEBUG, "******************** "));
#if 0
  ACE_DEBUG ((LM_DEBUG, "%s = %s ", "message_block", result.message_block ().rd_ptr ()));
#endif

  // Release message block.
  result.message_block ().release ();
}

 

代码中使用了result中发数据，然后把消息块释放了，就这么简单。

////////////////////////////////////////////////////////////////////////////////////////////////////

这是简单的proactor用法，当然，复杂也基本就这样用。所谓不基本的不是Proactor的内容，而是服务器编程本身的麻烦。比如说，多个连接的管理、重发机制、发送队列等等，这都不是ACE的内容。这些要大家自己思考了，并添加。

在这里，我要说几个重要的问题：连接的管理。Acceptor是一个类，但是在每一个连接，Proactor都用了某种办法创建了一个实例，所以，连接管理的群集类一定不能在Acceptor类中，不然得到的结果就是始终只有一条记录。因为每个Acceptor都有一个实例，实例对应一个连接，群集类也就每个实例一个了。要采取的方法是一个全局的容器对象就可以了。比如我这个类：

typedef ACE_Map_Manager <ACE_HANDLE, ConnectionBean *, ACE_Null_Mutex> ConnectionMap;
typedef ACE_Map_Iterator<ACE_HANDLE, ConnectionBean *, ACE_Null_Mutex> ConnectionIterator;
typedef ACE_Map_Entry   <ACE_HANDLE, ConnectionBean *> ConnectionEntry;

class Globle
{
public:
 Globle(void);
 ~Globle(void);

 ITPServer* server_;
 ConnectionMap _connections;

 unsigned getIndex(void); 
 long getTimerId(void);

private:
 unsigned int index_;

 long timerId_;
};

typedef ACE_Singleton<Globle, ACE_Null_Mutex> GlobleSingleton;

 

我使用ACE的Singleton模板创建这个类，每一个Acceptor要使用ConnectionMap，都使用这里的_connections，方法如下 ：
  GlobleSingleton::instance()->connection.bind()......

这个问题可是我花费了2天时间找出来的，诸位同仁不可不戒啊，给点掌声：）