快速理解ace库以及它是如何包装完成端口的

符号说明
=>表示有这个成员
->表示有这些子类
. 表示类的成员
==>表示调用
-->接着调用
R_N 重复N次

1.ACE采用了声明和实现分离的方式，来完成各个模块，并且实现这个模式中的统一思想为：包装类 => 实现类的基类 -> 各具体实现类．

要想很好的看懂ace的代码，理解这个模式是很重要的，因为通常需要定位到具体的实现类上去看源代码，以下列出了ACE几个核心的类的实现类：
 ACE_Reactor =>
  ACE_Reactor_Impl -> (ACE_Select_Reactor_Impl, ACE_WFMO_Reactor, ACE_Dev_Poll_Reactor);
 
 ACE_Proactor =>
  ACE_Proactor_Impl -> (ACE_WIN32_Proactor, ACE_POSIX_Proactor);

 ACE_Asynch_Accept =>
  ACE_Asynch_Accept_Impl -> (ACE_WIN32_Asynch_Accept_Result, ACE_POSIX_Asynch_Accept_Result);

 ACE_Asynch_Operation =>
  ACE_Asynch_Operation_Impl(重载了open函数）
       -> ACE_Asynch_Accept_Impl -> (ACE_WIN32_Asynch_Accept, ACE_POSIX_Asynch_Accept);

       -> ACE_Asynch_Connect_Impl -> (ACE_WIN32_Asynch_Connect, ACE_POSIX_Asynch_Connect);

       -> ACE_Asynch_Read_Stream_Impl -> (ACE_WIN32_Asynch_Read_Stream, ACE_POSIX_Asynch_Read_Stream,     

        ACE_Asynch_Read_File_Impl);

       -> ACE_Asynch_Write_Stream_Impl -> (ACE_WIN32_Asynch_Write_Stream, ACE_POSIX_Asynch_Write_Stream,
        ACE_Asynch_Write_File_Impl);

       -> ACE_POSIX_Asynch_Operation (ACE_WIN32_Asynch_Accept, ACE_WIN32_Asynch_Connect, ACE_WIN32_Asynch_Read_Stream,   

       ACE_WIN32_Asynch_Write_Stream, ACE_WIN32_Asynch_Transmit_File, ...)

       -> ACE_WIN32_Asynch_Operation, (ACE_POSIX_Asynch_Accept, ACE_POSIX_Asynch_Connect, ACE_POSIX_Asynch_Read_Stream,
       ACE_POSIX_Asynch_Write_Stream, ACE_POSIX_Asynch_Transmit_File,)
       -> ...
  
 ACE_Asynch_Result =>
  ACE_Asynch_Result_Impl  -> ACE_Asynch_Accept_Result_Impl (ACE_WIN32_Asynch_Accept_Result, ACE_POSIX_Asynch_Accept_Result);

     -> ACE_Asynch_Connect_Result_Impl ( ACE_WIN32_Asynch_Connect_Result, ACE_POSIX_Asynch_Connect_Result);

     -> ACE_Asynch_Read_Stream_Result_Impl ( ACE_WIN32_Asynch_Read_Stream_Result, ACE_POSIX_Asynch_Read_Stream_Result);

     -> ACE_Asynch_Write_Stream_Result_Impl (ACE_WIN32_Asynch_Write_Stream_Result, ACE_POSIX_Asynch_Write_Stream_Result);

     -> ACE_WIN32_Asynch_Result

     -> ACE_POSIX_Asynch_Result
 

1.接受器(Acceptor)，连接器(Connector)　是ACE对SOCKET在网络通信中不同作用的分类,它们都有两种模式，同步模式，异步模式．
对应的类分别是：接受器 ACE_Acceptor, ACE_Asynch_Acceptor. 连接器 ACE_Connector, ACE_Asynch_connector

接受器(Acceptor)，连接器(Connector)　都需要1个事件派发器．

事件分派器有2种:Reactor（反应器）, Proactor(前摄器), 对应同步和异步模式．
Reactor  用于同步模式的 接受器（ACE_Acceptor）和 连接器(ACE_Connector) 的事件派发回调
Proactor 用于异步模式的 接受器（ACE_Asynch_Acceptor) 和 连接器(ACE_Asynch_Connector) 的事件派发回调

事件分派器都有一个外壳类，分别是ACE_Reactor, ACE_Proactor, 封装了一个真正的实现:成员变量 implementation_, 大部分对Reactor或Proactor的函数调用，其实都是在调用实类对像的相应函数．其中， ACE_WIN32_Proactor 作为　ACE_Proactor 的一个实现，它封装了完成端口的系列代码． ACE_POSIX_Proactor 则封装了支持多种发起异步I/O操作并检测其完成的机制．

整个完成端口机制实现主要由 类ACE_Asynch_Acceptor 配合 ACE_WIN32_Proactor 来完成.
具体步骤

ACE_Asynch_Acceptor类的open函数需要传入一个ACE_Proactor指针．如果需要完成端口，则传入ACE_Proactor(new ACE_WIN32_Proactor).

具体实现过程是这样的：

a. ACE_Asynch_Acceptor.open()==>

  -->ACE_Asynch_Acceptor.asynch_accept_.open(ACE_Asynch_Acceptor.*this, listen_handle)==>

   ACE_Asynch_Operation.open(ACE_Asynch_Acceptor.proxy(), listen_handle)==>

   ACE_WIN32_Asynch_Accept.open(ACE_Asynch_Acceptor.proxy(), listen_handle)==>

   ACE_WIN32_Asynch_Operation.open(ACE_Asynch_Acceptor.proxy(), listen_handle)==>

   ACE_WIN32_Asynch_Operation.win32_proactor_->register_handle(listen_handle)==>

   ::CreateIoCompletionPort(listen_handle);　 --完成了listen_handle的完成端口注册

  函数继续执行，以下重复几次：

   -->ACE_Asynch_Acceptor.accept() ==>

   ACE_Asynch_Acceptor.asynch_accept_.accept() ==>  (asynch_accept_ 为 ACE_Asynch_Accept_Impl 类型)

   ACE_WIN32_Asynch_Accept.accept() ==>

    -->accept_handle = ACE_OS::socket(); --新的socket句柄

    -->ACE_WIN32_Asynch_Accept_Result* result = new ACE_WIN32_Asynch_Accept_Result;

    -->::AcceptEx(result.listen_handle, accept_handle);
 
   由上面可以看出，ACE_Asynch_Acceptor.open()之后,发出了N个异步接受连接,但是这些的accept_handle并没有向完成端口注册自己，所以这个时候的accept_handle事件在完成端口线程中是得不到的．

c. ACE_Asynch_Acceptor 中的HANDLER的具体类型必须继承自ACE_Service_Handler,
 并且ACE_Service_Handler.open()是一个空函数．未做任何操作．

b. 在外部线程中循环调用：

ACE_Proactor.handle_events() ==>

 ::GetQueuedCompletionStatus() --> ACE_WIN32_Asynch_Result.complete ==> --这是多态函数

如果是: ACE_WIN32_Asynch_Accept_Result.complete==> 

ACE_Asynch_Acceptor.handle_accept(result)==> 

  --> ACE_Asynch_Acceptor.validate_connection();

  --> HANDLER = ACE_Asynch_Acceptor.make_handler();

  --> HANDLER.handle(result.accept_handle()); --设置HANDLER的socket句柄

  --> HANDLER.open();

   从上面的c.我们知道，由于ACE_Service_Handler.open()未做任何事情，socket句柄依然处于未向完成端口注册状态．因此，
   HANDLERR::open()必须重载，并向完成端口注册socket句柄．

  --> ACE_Asynch_Acceptor.accept(); //重新投递一个连接侦听

如果是:ACE_WIN32_Asynch_Read_Stream_Result.complete==> 

  HANDLER.handle_read_stream(result);  --为什么是  HANDLER.handle_read_stream 而不是 ACE_Asynch_Acceptor.handle_read_stream?

                                                                             --是因为ACE_WIN32_Asynch_Read_Stream的handler一般是在HANDLERR::open()中赋值的.