摘要: 9.1 意图 　 接受器－连接器设计模式（Acceptor-Connector）使分布式系统中的连接建立及服务初始化与一旦服务初始化后所执行的处理去耦合。这样的去耦合通过三种组件来完成：acceptor、connector和service handler（服务处理器）。连接器主动地建立到远地接受器组件的连接，并初始化服务处理器来处理在连接上交...  阅读全文      摘要: 接受器/连接器模式设计用于降低连接建立与连接建立后所执行的服务之间的耦合。例如，在WWW浏览器中，所执行的服务或“实际工作”是解析和显示客户浏览器接收到的HTML页面。连接建立是次要的，可能通过BSD socket或其他一些等价的IPC机制来完成。使用这些模式允许程序员专注于“实际工作”，而最少限度地去关心怎样在服务器和客户之间建立连接。而另外一方面，程序员也可以独立于他所编写的、或将要编写的服务...  阅读全文

• 并发性：服务器必须同时执行多个客户请求；
• 效率：服务器必须最小化响应延迟、最大化吞吐量，并避免不必要地使用CPU；
• 编程简单性：服务器的设计应该简化高效的并发策略的使用；
• 可适配性：应该使继承新的或改进的传输协议（比如HTTP 1.1[3]）所带来的维护代价最小化。

1. 每个线程同步地阻塞在accept socket调用中，等待客户连接请求；
2. 客户连接到服务器，连接被接受；
3. 新客户的HTTP请求被同步地从网络连接中读取；
4. 请求被解析；
5. 所请求的文件被同步地读取；
6. 文件被同步地发送给客户。

1. Web服务器将Acceptor登记到Initiation Dispatcher，以接受新连接；
2. Web服务器调用Initiation Dispatcher的事件循环；
3. 客户连接到Web服务器；
4. Initiation Dispatcher将新连接请求通知Acceptor，后者接受新连接；
5. Acceptor创建HTTP Handler，以服务新客户；
6. HTTP Handler将连接登记到Initiation Dispatcher，以读取客户请求数据（就是说，在连接变得“读就绪”时）；
7. HTTP Handler服务来自新客户的请求。

1. 客户发送HTTP GET请求；
2. 当客户请求数据到达服务器时，Initiation Dispatcher通知HTTP Handler；
3. 请求以非阻塞方式被读取，于是如果操作会导致调用线程阻塞，读操作就返回EWOULDBLOCK（步骤2和3将重复直到请求被完全读取）；
4. HTTP Handler解析HTTP请求；
5. 所请求的文件从文件系统中被同步读取；
6. 为发送文件数据（就是说，当连接变得“写就绪”时），HTTP Handler将连接登记到Initiation Dispatcher；
7. 当TCP连接变得写就绪时，Initiation Dispatcher通知HTTP Handler；
8. HTTP Handler以非阻塞方式将所请求文件发送给客户，于是如果操作会导致调用线程阻塞，写操作就返回EWOULDBLOCK（步骤7和8将重复直到数据被完全递送）。

1. Web服务器指示Acceptor发起异步接受；
2. 接受器通过OS发起异步接受，将其自身作为Completion Handler和Completion Dispatcher的引用传递；并将用于在异步接受完成时通知Acceptor；
3. Web服务器调用Completion Dispatcher的事件循环；
4. 客户连接到Web服务器；
5. 当异步接受操作完成时，操作系统通知Completion Dispatcher；
6. Completion Dispatcher通知接受器；
7. Acceptor创建HTTP Handler；
8. HTTP Handler发起异步操作，以读取来自客户的请求数据，并将其自身作为Completion Handler和Completion Dispatcher的引用传递；并将用于在异步读取完成时通知HTTP Handler。

1. 客户发送HTTP GET请求；
2. 读取操作完成，操作系统通知Completion Dispatcher；
3. Completion Dispatcher通知HTTP Handler（步骤2和3将重复直到整个请求被接收）；
4. HTTP Handler解析请求；
5. HTTP Handler同步地读取所请求的文件；
6. HTTP Handler发起异步操作，以把文件数据写到客户连接，并将其自身作为Completion Handler和Completion Dispatcher的引用传递；并将用于在异步写入完成时通知HTTP Handler。
7. 当写操作完成时，操作系统通知Completion Dispatcher；
8. 随后Completion Dispatcher通知Completion Handler（步骤6-8将重复直到文件被完全递送）。

• 应用需要执行一个或多个不阻塞调用线程的异步操作；
• 当异步操作完成时应用必须被通知；
• 应用需要独立于它的I/O模型改变它的并发策略；
• 通过使依赖于应用的逻辑与应用无关的底层构造去耦合，应用将从中获益；
• 当使用多线程方法或反应式分派方法时，应用的执行将很低效，或是不能满足性能需求。

• Proactive Initiator是应用中任何发起Asynchronous Operation（异步操作）的实体。它将Completion Handler和Completion Dispatcher登记到Asynchronous Operation Processor（异步操作处理器），此处理器在操作完成时通知前摄发起器。

• 前摄器模式将应用所实现的Completion Handler接口用于Asynchronous Operation完成通知。

• Asynchronous Operation被用于代表应用执行请求（比如I/O和定时器操作）。当应用调用Asynchronous Operation时，操作的执行没有借用应用的线程控制。因此，从应用的角度来看，操作是被异步地执行的。当Asynchronous Operation完成时，Asynchronous Operation Processor将应用通知委托给Completion Dispatcher。

• Asynchronous Operation是由Asynchronous Operation Processor来运行直至完成的。该组件通常由OS实现。

• Completion Dispatcher负责在Asynchronous Operation完成时回调应用的Completion Handler。当Asynchronous Operation Processor完成异步发起的操作时，Completion Dispatcher代表应用执行应用回调。

1. 前摄发起器发起操作：为执行异步操作，应用在Asynchronous Operation Processor上发起操作。例如，Web服务器可能要求OS在网络上使用特定的socket连接传输文件。要请求这样的操作，Web服务器必须指定要使用哪一个文件和网络连接。而且，Web服务器必须指定（1）当操作完成时通知哪一个Completion Handler，以及（2）一旦文件被传输，哪一个Completion Dispatcher应该执行回调。
2. 异步操作处理器执行操作：当应用在Asynchronous Operation Processor上调用操作时，它相对于其他应用操作异步地运行这些操作。现代操作系统（比如Solaris和Windows NT）在内核中提供异步的I/O子系统。
3. 异步操作处理器通知完成分派器：当操作完成时，Asynchronous Operation Processor取得在操作被发起时指定的Completion Handler和Completion Dispatcher。随后Asynchronous Operation Processor将Asynchronous Operation的结果和Completion Handler传递给Completion Dispatcher，以用于回调。例如，如果文件已被异步传输，Asynchronous Operation Processor可以报告完成状态（比如成功或失败），以及写入网络连接的字节数。
4. 完成分派器通知应用：Completion Dispatcher在Completion Handler上调用完成挂钩，将由应用指定的任何完成数据传递给它。例如，如果异步读取完成，通常一个指向新到达数据的指针将会被传递给Completion Handler。

1. 操作调用：因为操作将在与进行调用的应用线程不同的线程控制中执行，必定会发生某种类型的线程同步。一种方法是为每个操作派生一个线程。更为常用的方法是为Asynchronous Operation Processor而管理一个专用线程池。该方法可能需要应用线程在继续进行其他应用计算之前将操作请求排队。
2. 操作执行：既然操作将在专用线程中执行，所以它可以执行“阻塞”操作，而不会直接阻碍应用的进展。例如，在提供异步I/O读取机制时，专用线程可以在从socket或文件句柄中读时阻塞。
3. 操作完成：当操作完成时，应用必须被通知到。特别是，专用线程必须将应用特有的通知委托给Completion Dispatcher。这要求在线程间进行另外的同步。

1. Completion Handler不会被迫输出特定的接口；以及
2. 在Completion Dispatcher和Completion Handler之间不需要有编译时依赖。

    ACE_INET_Addr类，包装了网络地址
    ACE_SOCK_Connector类，扮演主动连接角色，发起通讯连接。连接到远端的服务。
    ACE_SOCK_Acceptor类，扮演被动连接角色，等待连接。等待远端客户的请求。
    ACE_SOCK_Stream类，扮演数据通讯角色，发送和接收数据。完成客户与服务之间的通讯。
   
    利用ACE库来开发网络通讯程序是很简单的，一个基本程序只用到以上提到的几个类，就
可以完成一个基于客户端、服务器端模型的网络应用的开发。开发者无需了解Socket在不同平
台上的实现，记忆众多并相互关联的Socket APIs。

    一下以一个Hello World程序为演示。
   
    客户端程序。发送一个Hello World到远端的服务器，并接收服务器返回的信息，将信息
打印在屏幕上。

#include <iostream>
#include <string>

#include <ace/ACE.h>
#include <ace/INET_Addr.h>
#include <ace/SOCK_Connector.h>
#include <ace/SOCK_Stream.h>

int main( int argc, char* argv[] )
{
 ACE::init();//初始化ACE库，在windows下一定要

 std::string str = "hello world";

 //设置服务器地址
 //第一个参数是端口，第二个是ip地址，也可以是域名。
 //可以先定义一个地址对象，再用ACE_INET_Addr的set函数来设定。
 //地址的配置很多，具体的参照文档
 ACE_INET_Addr peer_addr( 5050, "127.0.0.1" );
 ACE_SOCK_Stream peer_stream;//定义一个通讯队形

 ACE_SOCK_Connector peer_connector;//定义一个主动连接对象
 peer_connector.connect( peer_stream, peer_addr );//发起一个连接

 peer_stream.send( str.c_str(), str.length() );//发送数据到服务器

 str.erase();
 str.resize( sizeof( "hello world" ) );
 peer_stream.recv( (void*)str.c_str(), str.length() );//接收来自服务器的信息

 std::cout << "from server message : " << str << std::endl;

    ACE::fini();
 return 0;
}

    服务器端代码。接收一个远端的连接，将接收到的信息打印在屏幕上，并将接收到的信
息返回给客户端。
#include <iostream>
#include <string>

#include <ace/ACE.h>
#include <ace/SOCK_Acceptor.h>
#include <ace/SOCK_Stream.h>

int main( int argc, char* argv[] )
{
 ACE::init();

 std::string str;
 str.resize( sizeof( "hello world" ) );

 //设置服务器地址
 ACE_INET_Addr peer_addr( 5050, "127.0.0.1" );

 ACE_SOCK_Stream peer_stream;
 
 //创建被动连接角色对象
 ACE_SOCK_Acceptor peer_acceptor;
 //开启被动连接对象，将对象绑定到一个地址上
 peer_acceptor.open( peer_addr );

 //等待连接
 peer_acceptor.accept( peer_stream );

 //数据通讯
 peer_stream.recv( (void*)str.c_str(), str.length() );
 std::cout << "from client message : " << str << std::endl;
 peer_stream.send( str.c_str(), str.length() );

 ACE::fini();
 return 0;
}
××××以上代码需要ACE库才能运转××××
   
    利用ACE编程的基本框架。
    客户端
    1 创建地址对象。（ACE_INET_Addr）
    2 创建主动连接对象。（ACE_SOCK_Connector）
    3 创建数据通讯对象。（ACE_SOCK_Stream）
    4 设置服务器地址。（ACE_INET_Addr::set）
    5 将数据通讯对象和地址作为参数传给主动连接对象，发起主动连接（ACE_SOCK_Connector::connect）
    6 利用通讯对象接收和发送数据。（ACE_SOCK_Stream::recv和ACE_SOCK_Stream::send）
   
    服务器端
    1 创建地址对象。（ACE_INET_Addr）
    2 创建被动连接对象。（ACE_SOCK_Connector）
    3 创建数据通讯对象。（ACE_SOCK_Stream）
    4 设置服务器地址。（ACE_INET_Addr::set）
    5 将地址作为参数传给被动连接对象，启动接收（ACE_SOCK_Acceptor::open）
    6 将数据通讯对象传给被动连接对象，启动接收，接受连接（ACE_SOCK_Connector::accept）
    7 利用通讯对象接收和发送数据。（ACE_SOCK_Stream::recv和ACE_SOCK_Stream::send）

    ACE_IPC_SAP类是IPC类族的基类，封装了句柄，提供了访问句柄的基本接口，基本结构
如下
class ACE_IPC_SAP
{
public:
  int enable (int value) const;
  int disable (int value) const;

  ACE_HANDLE get_handle (void) const;
  void set_handle (ACE_HANDLE handle);

protected:
  ACE_IPC_SAP (void);
  ~ACE_IPC_SAP (void);

private:
  ACE_HANDLE handle_;
};

    ACE_SOCK类是使用Socket的基类，所有使用Socket通讯的类都从这个类派生。本类的功
能包括
    1 创建和销毁Socket句柄
    2 获取本地和远端的网络地址
    3 设置和读取Socket选项。
基本结构如下
class ACE_SOCK : public ACE_IPC_SAP
{
public:
  //设置Socket的属性，包装了setsockopt系统函数
  int set_option (int level,
                  int option,
                  void *optval,
                  int optlen) const;
  //获取Socket的属性，包装了getsockopt系统函数
  int get_option (int level,
                  int option,
                  void *optval,
                  int *optlen) const;
  //获得本地地址
  int get_local_addr (ACE_Addr &) const;
  //获取远端地址
  int get_remote_addr (ACE_Addr &) const;
  //关闭Socket
  int close (void);
  //打开一个Socket，没有Qos
  int open (int type,
            int protocol_family,
            int protocol,
            int reuse_addr);
  //打开一个Socket，有Qos
  int open (int type,
            int protocol_family,
            int protocol,
            ACE_Protocol_Info *protocolinfo,
            ACE_SOCK_GROUP g,
            u_long flags,
            int reuse_addr);

protected:
  ACE_SOCK (int type,
            int protocol_family,
            int protocol = 0,
            int reuse_addr = 0);
  ACE_SOCK (int type,
            int protocol_family,
            int protocol,
            ACE_Protocol_Info *protocolinfo,
            ACE_SOCK_GROUP g,
            u_long flags,
            int reuse_addr);
  ACE_SOCK (void);
  ~ACE_SOCK (void);
};

    ACE_SOCK_IO类，包装了Socket数据通讯的基本方法。本类提供的功能
    1 支持数据的发送和接收
    2 支持分散读操作
    3 支持集中写操作
    4 支持阻塞，非阻塞，定时 I/O操作
基本结构如下
class ACE_SOCK_IO : public ACE_SOCK
{
public:
  ACE_SOCK_IO (void);
  ~ACE_SOCK_IO (void);

  //接收数据
  ssize_t recv (void *buf,
                size_t n,
                const ACE_Time_Value *timeout = 0) const;
  //分散读操作
  ssize_t recv (iovec iov[],
                size_t n,
                const ACE_Time_Value *timeout = 0) const;
  //发送数据             
  ssize_t send (const void *buf,
                size_t n,
                const ACE_Time_Value *timeout = 0) const;
  //集中写操作
  ssize_t send (const iovec iov[],
                size_t n,
                const ACE_Time_Value *timeout = 0) const;
};

    ACE_SOCK_Stream类，继承ACE_SOCK_IO类。在ACE_SOCK_IO类提供的功能上，添加了发送
和接收刚好n个字节的能力。基本结构如下
class ACE_Export ACE_SOCK_Stream : public ACE_SOCK_IO
{
public:
  ACE_SOCK_Stream (void);
  ACE_SOCK_Stream (ACE_HANDLE h);
  ~ACE_SOCK_Stream (void);
 
  //刚好读取n个字节的数据
  ssize_t recv_n (void *buf,
                  size_t len,
                  const ACE_Time_Value *timeout = 0,
                  size_t *bytes_transferred = 0) const;
  //分散读刚好n个字节操作
  ssize_t recvv_n (iovec iov[],
                   int iovcnt,
                   const ACE_Time_Value *timeout = 0,
                   size_t *bytes_transferred = 0) const;
  //刚好发送n个字节的数据
  ssize_t send_n (const void *buf,
                  size_t len,
                  const ACE_Time_Value *timeout = 0,
                  size_t *bytes_transferred = 0) const;
  //集中写刚好n个字节操作
  ssize_t sendv_n (const iovec iov[],
                   int iovcnt,
                   const ACE_Time_Value *timeout = 0,
                   size_t *bytes_transferred = 0) const;

  int close_reader (void);
  int close_writer (void);

  int close (void);

  typedef ACE_INET_Addr PEER_ADDR;
};

    ACE_SOCK_Acceptor类是一个工厂类，用来被动产生一个新的通讯端点。提供如下能力
    1 接收对等端的连接
    2 连接可以通过阻塞、非阻塞或定时方式接受。
基本结构如下
class ACE_Export ACE_SOCK_Acceptor : public ACE_SOCK
{
public:

  ACE_SOCK_Acceptor (void);
  ACE_SOCK_Acceptor (const ACE_Addr &local_sap,
                     int reuse_addr = 0,
                     int protocol_family = PF_UNSPEC,
                     int backlog = ACE_DEFAULT_BACKLOG,
                     int protocol = 0);
  ~ACE_SOCK_Acceptor (void);

  //打开一个监听
  int open (const ACE_Addr &local_sap,
            int reuse_addr = 0,
            int protocol_family = PF_UNSPEC,
            int backlog = ACE_DEFAULT_BACKLOG,
            int protocol = 0);

  int close (void);
  //接受一个对等端的连接，产生一个通讯
  int accept (ACE_SOCK_Stream &new_stream,
              ACE_Addr *remote_addr = 0,
              ACE_Time_Value *timeout = 0,
              int restart = 1,
              int reset_new_handle = 0) const;
};

    ACE_SOCK_Connector类是一个工厂类，用来主动建立一个新的通讯端。提供的功能如下
    1 发起一个到对等接受者的连接，并在连接后产生一个通讯对象
    2 连接可以通过阻塞、非阻塞或定时方式发起
基本结构如下
class ACE_SOCK_Connector
{
public:
  ACE_SOCK_Connector (void);
  ACE_SOCK_Connector (ACE_SOCK_Stream &new_stream,
                      const ACE_Addr &remote_sap,
                      const ACE_Time_Value *timeout = 0,
                      const ACE_Addr &local_sap = ACE_Addr::sap_any,
                      int reuse_addr = 0,
                      int flags = 0,
                      int perms = 0,
                      int protocol = 0);

  //发起一个连接
  int connect (ACE_SOCK_Stream &new_stream,
               const ACE_Addr &remote_sap,
               const ACE_Time_Value *timeout = 0,
               const ACE_Addr &local_sap = ACE_Addr::sap_any,
               int reuse_addr = 0,
               int flags = 0,
               int perms = 0,
               int protocol = 0);

  ~ACE_SOCK_Connector (void);

  int complete (ACE_SOCK_Stream &new_stream,
                ACE_Addr *remote_sap = 0,
                const ACE_Time_Value *timeout = 0);
};

    以上的类结构是简化的，以突出重点功能。要完全了解每个类，看源代码。

    多路分配的入口函数handle_events，在框架的实现接口类中定义
    多路分配的主体实现函数event_handling,在ACE_WFMO_Reactor中定义，伪
实现代码如下
int ACE_WFMO_Reactor::event_handling (ACE_Time_Value *max_wait_time,
                                      int alertable)
{
  int result = 0;
 
  do
  {
      //等待在句柄集上发生的事件
      //wait_for_multiple_events的具体实现是使用
      //WaitForMultipleObjectsEx函数
      DWORD wait_status = this->wait_for_multiple_events (timeout,
                                                          alertable);
      //分发事件
      result = this->safe_dispatch (wait_status);
  }while (result == 0);

  return result;
}

    分发的主体函数是dispatch_handles,在ACE_WFMO_Reactor中定义，伪实现
代码如下
int ACE_WFMO_Reactor::dispatch_handles (DWORD wait_status)
{
  DWORD dispatch_slot = 0;

  //活动的句柄总数
  DWORD max_handlep1 = this->handler_rep_.max_handlep1 ();

  //查找要分发的句柄的索引
  for (int number_of_handlers_dispatched = 1;;++number_of_handlers_dispatched)
  {
      //计算有事件发生，要分发的句柄索引
      dispatch_slot += wait_status - WAIT_OBJECT_0;
      //分发给相应的事件处理对象
      if (this->dispatch_handler (dispatch_slot, max_handlep1) == -1)
        return -1;

      ++dispatch_slot;

      if (dispatch_slot >= max_handlep1)
        return number_of_handlers_dispatched;//分发了几个事件

      //检查剩下的句柄中有没有有事件发生的
      wait_status = this->poll_remaining_handles (dispatch_slot);
      switch (wait_status)
      {
        case WAIT_FAILED: // Failure.
          ACE_OS::set_errno_to_last_error ();
          /* FALLTHRU */
        case WAIT_TIMEOUT:
          // There are no more handles ready, we can return.
          return number_of_handlers_dispatched;//分发了几个事件
      }
  }
}

    找到具体事件处理对象主体函数complex_dispatch_hander,在ACE_WFMO_Reactor
中定义，为代码如下
int ACE_WFMO_Reactor::complex_dispatch_handler (DWORD slot,
                                                ACE_HANDLE event_handle)
{
  //找到当前的分发的信息
  ACE_WFMO_Reactor_Handler_Repository::Current_Info &current_info =
    this->handler_rep_.current_info ()[slot];

  WSANETWORKEVENTS events;
  ACE_Reactor_Mask problems = ACE_Event_Handler::NULL_MASK;
  if (::WSAEnumNetworkEvents ((SOCKET) current_info.io_handle_,
                              event_handle,
                              &events) == SOCKET_ERROR)
    problems = ACE_Event_Handler::ALL_EVENTS_MASK;
  else
  {
      //发生的事件于要检测的事件是否相同，相同就分发
      events.lNetworkEvents &= current_info.network_events_;
      while (events.lNetworkEvents != 0)
      {
          ACE_Event_Handler *event_handler = current_info.event_handler_;

          //调用事件处理对象，进行事件处理
          problems |= this->upcall (current_info.event_handler_,
                                    current_info.io_handle_,
                                    events);

          if (this->handler_rep_.scheduled_for_deletion (slot))
            break;
      }
  }

  return 0;
}

1
int ACE_WFMO_Reactor::handle_events (ACE_Time_Value &how_long)
{
  return this->event_handling (&how_long, FALSE);
}

2
// Waits for and dispatches all events.  Returns -1 on error, 0 if
// max_wait_time expired, or the number of events that were dispatched.
int ACE_WFMO_Reactor::event_handling (ACE_Time_Value *max_wait_time,
                                      int alertable)
{
  ACE_TRACE ("ACE_WFMO_Reactor::event_handling");

  // Make sure we are not closed
  if (!this->open_for_business_ || this->deactivated_)
      return -1;

  // Stash the current time -- the destructor of this object will
  // automatically compute how much time elapsed since this method was
  // called.
  ACE_Countdown_Time countdown (max_wait_time);

  int result;
 
  do
  {
      // Check to see if it is ok to enter ::WaitForMultipleObjects
      // This will acquire <this->lock_> on success On failure, the
      // lock will not be acquired
     
      result = this->ok_to_wait (max_wait_time, alertable);
      if (result != 1)
        return result;

      // Increment the number of active threads
      ++this->active_threads_;

      // Release the <lock_>
      this->lock_.release ();

      // Update the countdown to reflect time waiting to play with the
      // mut and event.
     
      countdown.update ();

      // Calculate timeout
      int timeout = this->calculate_timeout (max_wait_time);

      // Wait for event to happen
      DWORD wait_status = this->wait_for_multiple_events (timeout,
                                                          alertable);

      // Upcall
      result = this->safe_dispatch (wait_status);
      if (0 == result)
      {
          // wait_for_multiple_events timed out without dispatching
          // anything.  Because of rounding and conversion errors and
          // such, it could be that the wait loop timed out, but
          // the timer queue said it wasn't quite ready to expire a
          // timer. In this case, max_wait_time won't have quite been
          // reduced to 0, and we need to go around again. If max_wait_time
          // is all the way to 0, just return, as the entire time the
          // caller wanted to wait has been used up.
          countdown.update ();     // Reflect time waiting for events
         
          if (0 == max_wait_time || max_wait_time->usec () == 0)
            break;
      }
  }while (result == 0);

  return result;
}

3
int ACE_WFMO_Reactor::safe_dispatch (DWORD wait_status)
{
  int result = -1;
  ACE_SEH_TRY
  {
      result = this->dispatch (wait_status);
  }
  ACE_SEH_FINALLY
  {
      this->update_state ();
  }

  return result;
}

4
int ACE_WFMO_Reactor::dispatch (DWORD wait_status)
{
  int handlers_dispatched = 0;

  // Expire timers
  handlers_dispatched += this->expire_timers ();

  switch (wait_status)
  {
  case WAIT_FAILED: // Failure.
      ACE_OS::set_errno_to_last_error ();
      return -1;

  case WAIT_TIMEOUT: // Timeout.
      errno = ETIME;
      return handlers_dispatched;

  default:  // Dispatch.
      // We'll let dispatch worry about abandoned mutes.
      handlers_dispatched += this->dispatch_handles (wait_status);
      return handlers_dispatched;
  }
}

5
// Dispatches any active handles from <handles_[slot]> to
// <handles_[max_handlep1_]>, polling through our handle set looking
// for active handles.

int ACE_WFMO_Reactor::dispatch_handles (DWORD wait_status)
{
  // dispatch_slot is the absolute slot.  Only += is used to
  // increment it.
  DWORD dispatch_slot = 0;

  // Cache this value, this is the absolute value.
  DWORD max_handlep1 = this->handler_rep_.max_handlep1 ();

  // nCount starts off at <max_handlep1>, this is a transient count of
  // handles last waited on.
  DWORD nCount = max_handlep1;

  for (int number_of_handlers_dispatched = 1;;++number_of_handlers_dispatched)
  {
      const bool ok = (wait_status >= WAIT_OBJECT_0 && wait_status <= (WAIT_OBJECT_0 + nCount));

      if (ok)
        dispatch_slot += wait_status - WAIT_OBJECT_0;
      else
        // Otherwise, a handle was abandoned.
        dispatch_slot += wait_status - WAIT_ABANDONED_0;

      // Dispatch handler
      if (this->dispatch_handler (dispatch_slot, max_handlep1) == -1)
        return -1;

      // Increment slot
      ++dispatch_slot;

      // We're done.
      if (dispatch_slot >= max_handlep1)
        return number_of_handlers_dispatched;

      // Readjust nCount
      nCount = max_handlep1 - dispatch_slot;

      // Check the remaining handles
      wait_status = this->poll_remaining_handles (dispatch_slot);
      switch (wait_status)
      {
        case WAIT_FAILED: // Failure.
          ACE_OS::set_errno_to_last_error ();
          /* FALLTHRU */
        case WAIT_TIMEOUT:
          // There are no more handles ready, we can return.
          return number_of_handlers_dispatched;
      }
  }
}

6
int ACE_WFMO_Reactor::dispatch_handler (DWORD slot,
                                        DWORD max_handlep1)
{
  // Check if there are window messages that need to be dispatched
  if (slot == max_handlep1)
    return this->dispatch_window_messages ();

  // Dispatch the handler if it has not been scheduled for deletion.
  // Note that this is a very week test if there are multiple threads
  // dispatching this slot as no locks are held here. Generally, you
  // do not want to do something like deleting the this pointer in
  // handle_close() if you have registered multiple times and there is
  // more than one thread in WFMO_Reactor->handle_events().
  else if (!this->handler_rep_.scheduled_for_deletion (slot))
  {
      ACE_HANDLE event_handle = *(this->handler_rep_.handles () + slot);

      if (this->handler_rep_.current_info ()[slot].io_entry_)
        return this->complex_dispatch_handler (slot,
                                               event_handle);
      else
        return this->simple_dispatch_handler (slot,
                                              event_handle);
  }
  else
    // The handle was scheduled for deletion, so we will skip it.
    return 0;
}

7
int ACE_WFMO_Reactor::complex_dispatch_handler (DWORD slot,
                                                ACE_HANDLE event_handle)
{
  // This dispatch is used for I/O entires.

  ACE_WFMO_Reactor_Handler_Repository::Current_Info &current_info =
    this->handler_rep_.current_info ()[slot];

  WSANETWORKEVENTS events;
  ACE_Reactor_Mask problems = ACE_Event_Handler::NULL_MASK;
  if (::WSAEnumNetworkEvents ((SOCKET) current_info.io_handle_,
                              event_handle,
                              &events) == SOCKET_ERROR)
    problems = ACE_Event_Handler::ALL_EVENTS_MASK;
  else
  {
      // Prepare for upcalls. Clear the bits from <events> representing
      // events the handler is not interested in. If there are any left,
      // do the upcall(s). upcall will replace events.lNetworkEvents
      // with bits representing any functions that requested a repeat
      // callback before checking handles again. In this case, continue
      // to call back unless the handler is unregistered as a result of
      // one of the upcalls. The way this is written, the upcalls will
      // keep being done even if one or more upcalls reported problems.
      // In practice this may turn out not so good, but let's see. If any
      // problems, please notify Steve Huston <shuston@riverace.com>
      // before or after you change this code.
      events.lNetworkEvents &= current_info.network_events_;
      while (events.lNetworkEvents != 0)
      {
          ACE_Event_Handler *event_handler = current_info.event_handler_;

          int reference_counting_required =
            event_handler->reference_counting_policy ().value () ==
            ACE_Event_Handler::Reference_Counting_Policy::ENABLED;

          // Call add_reference() if needed.
          if (reference_counting_required)
          {
              event_handler->add_reference ();
          }

          // Upcall
          problems |= this->upcall (current_info.event_handler_,
                                    current_info.io_handle_,
                                    events);

          // Call remove_reference() if needed.
          if (reference_counting_required)
          {
              event_handler->remove_reference ();
          }

          if (this->handler_rep_.scheduled_for_deletion (slot))
            break;
      }
  }

  if (problems != ACE_Event_Handler::NULL_MASK
      && !this->handler_rep_.scheduled_for_deletion (slot)  )
    this->handler_rep_.unbind (event_handle, problems);

  return 0;
}

8
ACE_Reactor_Mask ACE_WFMO_Reactor::upcall (ACE_Event_Handler *event_handler,
                                           ACE_HANDLE io_handle,
                                           WSANETWORKEVENTS &events)
{
  // This method figures out what exactly has happened to the socket
  // and then calls appropriate methods.
  ACE_Reactor_Mask problems = ACE_Event_Handler::NULL_MASK;

  // Go through the events and do the indicated upcalls. If the handler
  // doesn't want to be called back, clear the bit for that event.
  // At the end, set the bits back to <events> to request a repeat call.

  long actual_events = events.lNetworkEvents;
  int action;

  if (ACE_BIT_ENABLED (actual_events, FD_WRITE))
  {
      action = event_handler->handle_output (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_WRITE);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::WRITE_MASK);
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_CONNECT))
  {
      if (events.iErrorCode[FD_CONNECT_BIT] == 0)
      {
          // Successful connect
          action = event_handler->handle_output (io_handle);
          if (action <= 0)
          {
              ACE_CLR_BITS (actual_events, FD_CONNECT);
              if (action == -1)
                ACE_SET_BITS (problems, ACE_Event_Handler::CONNECT_MASK);
          }
      }
      // Unsuccessful connect
      else
      {
          action = event_handler->handle_input (io_handle);
          if (action <= 0)
          {
              ACE_CLR_BITS (actual_events, FD_CONNECT);
              if (action == -1)
                ACE_SET_BITS (problems, ACE_Event_Handler::CONNECT_MASK);
          }
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_OOB))
  {
      action = event_handler->handle_exception (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_OOB);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::EXCEPT_MASK);
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_READ))
  {
      action = event_handler->handle_input (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_READ);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::READ_MASK);
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_CLOSE)
      && ACE_BIT_DISABLED (problems, ACE_Event_Handler::READ_MASK))
  {
      action = event_handler->handle_input (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_CLOSE);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::READ_MASK);
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_ACCEPT))
  {
      action = event_handler->handle_input (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_ACCEPT);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::ACCEPT_MASK);
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_QOS))
  {
      action = event_handler->handle_qos (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_QOS);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::QOS_MASK);
      }
  }

  if (ACE_BIT_ENABLED (actual_events, FD_GROUP_QOS))
  {
      action = event_handler->handle_group_qos (io_handle);
      if (action <= 0)
      {
          ACE_CLR_BITS (actual_events, FD_GROUP_QOS);
          if (action == -1)
            ACE_SET_BITS (problems, ACE_Event_Handler::GROUP_QOS_MASK);
      }
  }

  events.lNetworkEvents = actual_events;
  return problems;
}

        ACE这个开源项目的代码的量是很大的。对于系统编程、网络编程是非常的有用，但是对其介绍的书和资料是非常的少。要想了解和很好的使用，就必须要自己去看源代码了。（好在还有三本书，库中的事例还是比较的多）
        ACE库中的代码大体可以分为三大部分
        1  OS Adaptation（操作系统适配）部分。这部分主要是屏蔽各操作系统的API的不同，将系统调用接口统一到C＋＋函数的接口，以实现平台的可移植。
        2  C++ Wrapper Facade（C++外包）部分。这部分主要是将相互关联的操作和数据结构封装到C++类中，提供统一的接口。提供强类型的检测，降低不必要的认为错误。利用C++多态、继承等能力，形成一个架构，使本地的、远端的操作统一在一个相同接口和使用策略下。
        3  Framework（框架）部分。为一组相关的应用提供可复用的架构。开发者在确定了应用后，选择可用的架构开发应用程序，不用考虑平台和底层机制。快速的开发。
        第一部分面对大量的底层的细节，而且目标是平台的移植，如果对平台的移植感兴趣的兄弟姐妹可以看看。一般情况下没什么看的必要。
        第二部分和第三部分对我们的应用和学习如何利用C++来设计程序非常的有价值，要多看。细心揣摩，特别是配上设计的问题（宏观的和微观的）。         chown    设置文件或目录的所有权用户。
        chown 用户名.组名 文件或目录名。
       例 1 chown user.group directory  2 chown user.group file

        chmod    改变文件或目录的用户权限。
        一个文件或目录的用户权限由三个部分组成 所有者权限 所有者所在的组的权限 其他用户的权限。每个权限又由三种权力组成，读权力 写权力 执行权力
        例 1 chmod 711 file 所有者有读、写、执行权力
                                         所有者所在组用户有执行权力
                                         其他用户有执行权力         想学的时候就开始学习。听过设计模式，心动了，那就开始学吧。是的，开始时不能明白那里面写些什么，不要紧，先把它们背下来。里面的实例代码用手写一边，不要只是看一边。就看那本叫设计模式的书，这不是说那些以它为根本的注解的书不好，只是个人认为注解带有注解人的理解和思考，看了反而添加了更多的不理解的概念。将写过的代码拿出来，用模式的眼光去重新审视，有了想法就去编码实现，并不但的改进。