快速理解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<HANDLER> 配合 ACE_WIN32_Proactor 来完成.
具体步骤

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

具体实现过程是这样的:

a. ACE_Asynch_Acceptor<HANDLER>.open()==>

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

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

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

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

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

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

  函数继续执行,以下重复几次:

   -->ACE_Asynch_Acceptor<HANDLER>.accept() ==>

   ACE_Asynch_Acceptor<HANDLER>.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<HANDLER>.open()之后,发出了N个异步接受连接,但是这些的accept_handle并没有向完成端口注册自己,所以这个时候的accept_handle事件在完成端口线程中是得不到的.

c. ACE_Asynch_Acceptor<HANDLER> 中的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<HANDLER>.handle_accept(result)==> 

  --> ACE_Asynch_Acceptor<HANDLER>.validate_connection();

  --> HANDLER = ACE_Asynch_Acceptor<HANDLERR>.make_handler();

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

  --> HANDLER.open();

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

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


如果是:ACE_WIN32_Asynch_Read_Stream_Result.complete==> 

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

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

 

  • 1
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值