此文描述了组成ACE框架的Reactor模式的设计和执行。Reactor负责处理由一个或多个client并发的传递给一个应用程序的服务请求。应用程序的每个服务由一个分离的event handler（事件句柄）执行，event handler包括一个或多个进程的服务器特殊请求的方法。

       此文描述的Reactor模式的执行，event handler分发是由ACE_Reactor实现的。ACE_Reactor结合I/O事件的分离器，以及其他类型的时间，比如timers和signals。ACE_Reactor的核心实现是基于同步事件分离，比如select或者WaitForMultipleObjects。当分离器指示指定的事件发生了，ACE_Reactor会自动分发预先注册的事件句柄的方法。注册的event handler方法会完成应用程序对应请求事件的服务。

       本文组织如下：第二章描述ACE_Reactor框架主要特性；第三章大致介绍ACE_Reactor实现的OO（面向对象）设计；第四章举了服务器端实现的例子，用以证明ACE_Reactor怎样简化并发的，基于事件的网络应用程序的发展；第五章描述当使用ACE_Reactor开发基于事件的应用程序的设计规则；第六章是结束语。

2 ACE_Reactor的特性

ACE_Reactor提供OO的事件分离机制和消息分发框架，它简化基于事件的应用程序的开发。以下特性是：

OO的事件分离和消息分发接口：

使用ACE_Reactor的应用程序不直接调用底层OS（操作系统）的事件分离API函数。比如select或WaitForMultipleObjects。他们继承ACE Event Handler基类并创建了具体的event handlers。这个类用特定的虚拟函数处理不同类型的事件，比如I/O事件，timer事件，signals（信号量机制），和同步事件。

应用程序用Reactor框架创建具体的event handler，并注册他们。特性1显示了ACE Reactor.的关键组件。这个特性描述执行日子服务的事件句柄，这个在第四章讲述。

server端代码：
// 环境VC6.0+ACE5.4.2
// proj:ACE stream server
// date:07-7-24
// robin
//

#include "stdafx.h"

#include "ace/Log_Msg.h"
#include "ace/Time_Value.h"
#include "ace/OS.h"

#include "ace/SOCK_Acceptor.h"
#include "ace/SOCK_Stream.h"

#define SIZE_DATA 18
#define SIZE_BUF 1024
#define NO_ITERATIONS 5

class Server
{
public:
 Server (int port) : server_addr_(port),peer_acceptor_(server_addr_)
 {
  data_buf_ = new char[SIZE_BUF];
 }

 //Handle the connection once it has been established. Here the
 //connection is handled by reading SIZE_DATA amount of data from the
 //remote and then closing the connection stream down.

 int handle_connection()
 {
  // Read data from client
  for(int i=0;i<NO_ITERATIONS;i++)
  {
   int byte_count=0;
   if( (byte_count = new_stream_.recv_n(data_buf_, SIZE_DATA, 0) ) == -1 )
    ACE_ERROR ((LM_ERROR, "%p\n", "Error in recv"));
   else
   {
    data_buf_[byte_count]=0;
    ACE_DEBUG((LM_DEBUG,"Server received %s \n",data_buf_));
   }
  }

  // Close new endpoint
  if (new_stream_.close () == -1)
   ACE_ERROR ((LM_ERROR, "%p\n", "close"));
  return 0;
 }

 //Use the acceptor component peer_acceptor_ to accept the connection
 //into the underlying stream new_stream_. After the connection has been
 //established call the handle_connection() method.
 
 int accept_connections ()
 {
  if (peer_acceptor_.get_local_addr (server_addr_) == -1)
   ACE_ERROR_RETURN ((LM_ERROR,"%p\n","Error in get_local_addr"),1);
  ACE_DEBUG ((LM_DEBUG,"Starting server at port %d\n",
   server_addr_.get_port_number ()));
  
  // Performs the iterative server activities.

  while(1)
  {
   ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
   if (peer_acceptor_.accept(new_stream_, &client_addr_, &timeout)== -1)
   {
    ACE_ERROR ((LM_ERROR, "%p\n", "accept"));
    continue;
   }
   else
   {
    ACE_DEBUG((LM_DEBUG,
     "Connection established with remote %s:%d\n",
     client_addr_.get_host_name(),client_addr_.get_port_number()));

    //Handle the connection
    handle_connection();
   }
  }
 }

private:
 char *data_buf_;
 ACE_INET_Addr server_addr_;
 ACE_INET_Addr client_addr_;
 ACE_SOCK_Acceptor peer_acceptor_;
 ACE_SOCK_Stream new_stream_;
};

int main (int argc, char *argv[])
{
 if(argc<2)
 {
  ACE_ERROR((LM_ERROR,"Usage %s <port_num>", argv[0]));
  ACE_OS::exit(1);
 }

// char *ip;
// ip = new char[strlen("192.168.1.160")];
// Server server(ACE_OS::atoi(ip));  //argv[1])

 Server server(ACE_OS::atoi(argv[1]));
 server.accept_connections();
 return 0;
}

client端：
// proj:ACE stream client
// client
// date:7-24
// robin

#include "stdafx.h"

//******additional*******//
#include "ace/Log_Msg.h"  //ACE_ERROR ACE_DEBUG
#include "ace/Time_Value.h"  // ACE_Time_Value
#include "ace/OS.h"    // ACE_OS::atoi exit
//******additional*******//

#include "ace/SOCK_Connector.h"
#include "ace/INET_Addr.h"

#define SIZE_BUF 128
#define NO_ITERATIONS 5

class Client
{
public:
 Client(char *hostname, int port):remote_addr_(port,hostname)
 {
  data_buf_="Hello from Client";
 }

 //Uses a connector component `connector_’ to connect to a
 //remote machine and pass the connection into a stream
 //component client_stream_
 int connect_to_server()
 {
  // Initiate blocking connection with server.
  ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting connect to %s:%d\n",
   remote_addr_.get_host_name(),remote_addr_.get_port_number()));
  if (connector_.connect (client_stream_, remote_addr_) == -1)
   ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","connection failed"),-1);
  else
   ACE_DEBUG ((LM_DEBUG,"(%P|%t) connected to %s\n",
   remote_addr_.get_host_name ()));
  return 0;
 }

 //Uses a stream component to send data to the remote host.
 int send_to_server()
 {
  // Send data to server
  for(int i=0;i<NO_ITERATIONS; i++)
  {
   if (client_stream_.send_n (data_buf_,
    ACE_OS::strlen(data_buf_)+1, 0) == -1)
   {
    ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","send_n"),0);
    break;
   }
  }
  //Close down the connection
  close();
 }

 //Close down the connection properly.
 int close()
 {
  if (client_stream_.close () == -1)
   ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","close"),-1);
  else
   return 0;
 }
private:
 ACE_SOCK_Stream client_stream_;
 ACE_INET_Addr remote_addr_;
 ACE_SOCK_Connector connector_;
 char *data_buf_;
};

int main(int argc, char* argv[])
{
 if(argc<3)
 {
  ACE_DEBUG((LM_DEBUG,"Usage %s <hostname> <port_number>\n", argv[0]));
  ACE_OS::exit(1);
 }

 Client client(argv[1],ACE_OS::atoi(argv[2]));
 client.connect_to_server();
 client.send_to_server();
 return 0;
}

运行结果：
cmd里到exe目录下，先启动服务端server.exe 192.168.1.160
如图1：

正在轮询等待。

再到client服务端，同样的方法
运行命令行参数格式 client.exe 192.168.1.160 192
 解析：ACE_DEBUG((LM_DEBUG,"Usage %s <hostname> <port_number>\n", argv[0]));
         命令行参数为 <hostname><port> = <192.168.1.160><192>
         端口是由图1的第二行显示，不是自己设定的。
如图2：