ACE之Proactor框架

kgduu

已于 2025-01-02 14:43:55 修改

阅读量928

点赞数 17

分类专栏： ACE 文章标签： ACE

于 2024-07-23 22:52:10 首次发布

本文链接：https://blog.youkuaiyun.com/xiexingshishu/article/details/140648036

版权

ACE 专栏收录该内容

20 篇文章

订阅专栏

简介

Proactor使用的是异步io，其实现与Reactor相似，也使用桥接模式
ACE_Proactor 对ACE_Proactor_Impl
ACE_Asynch_Operation对ACE_Asynch_Operation_Impl
ACE_Asynch_Result对ACE_Asynch_Result_Impl

组成

handler, operation,result关系为

ACE_Handler

异步的处理类

ACE_Handler 其主要方法有

virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
virtual void handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result);
virtual void handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result);
virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result);
virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result);
virtual void handle_accept (const ACE_Asynch_Accept::Result &result);
virtual void handle_connect (const ACE_Asynch_Connect::Result &result);
virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result);
virtual void handle_time_out (const ACE_Time_Value &tv,const void *act = 0);
virtual void handle_wakeup (void);
ACE_Proactor *proactor (void);
void proactor (ACE_Proactor *p);
virtual ACE_HANDLE handle (void) const;
virtual void handle (ACE_HANDLE);
Proxy_Ptr &proxy (void);

ACE_Service_Handler：在ACE_Handler 基础上添加了open方法，子类继承ACE_Service_Handler主要是向Proactor注册

ACE_Asynch_Result

异步处理结果

ACE_Asynch_Result 方法有

public:
	size_t bytes_transferred (void) const;
	const void *act (void) const;
	int success (void) const;
	const void *completion_key (void) const;
	unsigned long error (void) const;
	ACE_HANDLE event (void) const;
	unsigned long offset (void) const;
  	unsigned long offset_high (void) const;
  	int priority (void) const;
  	int signal_number (void) const;
protected:
	ACE_Asynch_Result (ACE_Asynch_Result_Impl *implementation);
	ACE_Asynch_Result_Impl *implementation (void) const;

ACE_Asynch_Result_Impl :增加了complete和post_completion，在具体操作执行时，创建对应的结果对象，将操作中的Handler和handle传到结果中。其方法有

virtual size_t bytes_transferred (void) const = 0;
virtual const void *act (void) const = 0;
virtual int success (void) const = 0;
virtual const void *completion_key (void) const = 0;
virtual u_long error (void) const = 0;
virtual ACE_HANDLE event (void) const = 0;
virtual u_long offset (void) const = 0;
virtual u_long offset_high (void) const = 0;
virtual int priority (void) const = 0;
virtual int signal_number (void) const = 0;
virtual void complete (size_t bytes_transferred,
                         int success,
                         const void *completion_key,
                         u_long error = 0) = 0;
virtual int post_completion (ACE_Proactor_Impl *proactor) = 0;

ACE_Asynch_Operation

异步操作

ACE_Asynch_Operation 方法有

public:
	int open (ACE_Handler &handler,ACE_HANDLE handle,const void *completion_key,ACE_Proactor *proactor);
	int cancel (void);
	ACE_Proactor* proactor (void) const;
protected:
	virtual ACE_Asynch_Operation_Impl *implementation (void) const = 0;
	ACE_Proactor *get_proactor (ACE_Proactor *user_proactor,ACE_Handler &handler) const;

ACE_Asynch_Operation_Impl方法有

virtual int open (const ACE_Handler::Proxy_Ptr &handler_proxy,ACE_HANDLE handle,const void *completion_key,ACE_Proactor *proactor) = 0;
virtual int cancel (void) = 0;
virtual ACE_Proactor* proactor (void) const = 0;

ACE_Asynch_Operation_Impl

异步操作实现抽象类的子类

ACE_Asynch_Read_Stream_Impl：在基类基础上添加了read和readv

virtual int read (ACE_Message_Block &message_block,
                    size_t bytes_to_read,
                    const void *act,
                    int priority,
                    int signal_number) = 0;
virtual int readv (ACE_Message_Block &message_block,
                     size_t bytes_to_read,
                     const void *act,
                     int priority,
                     int signal_number) = 0;

ACE_Asynch_Write_Stream_Impl ：在基类基础上添加了write和writev

virtual int write (ACE_Message_Block &message_block,
                     size_t bytes_to_write,
                     const void *act,
                     int priority,
                     int signal_number) = 0;
virtual int writev (ACE_Message_Block &message_block,
                      size_t bytes_to_write,
                      const void *act,
                      int priority,
                      int signal_number) = 0;

ACE_Asynch_Read_File_Impl：在ACE_Asynch_Read_Stream_Impl基础上添加了read和readv

virtual int read (ACE_Message_Block &message_block,
                    size_t bytes_to_read,
                    u_long offset,
                    u_long offset_high,
                    const void *act,
                    int priority,
                    int signal_number) = 0;
virtual int readv (ACE_Message_Block &message_block,
                     size_t bytes_to_read,
                     u_long offset,
                     u_long offset_high,
                     const void *act,
                     int priority,
                     int signal_number) = 0;     
virtual int read (ACE_Message_Block &message_block,
                    size_t bytes_to_read,
                    const void *act,
                    int priority,
                    int signal_number) = 0;    
virtual int readv (ACE_Message_Block &message_block,
                     size_t bytes_to_read,
                     const void *act,
                     int priority,
                     int signal_number) = 0;

ACE_Asynch_Write_File_Impl：在ACE_Asynch_Write_Stream_Impl 基础上添加了write和writev

virtual int write (ACE_Message_Block &message_block,
                     size_t bytes_to_write,
                     u_long offset,
                     u_long offset_high,
                     const void *act,
                     int priority,
                     int signal_number) = 0;
virtual int writev (ACE_Message_Block &message_block,
                      size_t bytes_to_write,
                      u_long offset,
                      u_long offset_high,
                      const void *act,
                      int priority,
                      int signal_number) = 0;      
virtual int write (ACE_Message_Block &message_block,
                     size_t bytes_to_write,
                     const void *act,
                     int priority,
                     int signal_number) = 0;    
virtual int writev (ACE_Message_Block &message_block,
                      size_t bytes_to_write,
                      const void *act,
                      int priority,
                      int signal_number) = 0;

ACE_Asynch_Accept_Impl：在基类基础上添加了accept

virtual int accept (ACE_Message_Block &message_block,
                      size_t bytes_to_read,
                      ACE_HANDLE accept_handle,
                      const void *act,
                      int priority,
                      int signal_number,
                      int addr_family) = 0;

ACE_Asynch_Connect_Impl：在基类基础上添加了`connect

virtual int connect (ACE_HANDLE connect_handle,
                       const ACE_Addr & remote_sap,
                       const ACE_Addr & local_sap,
                       int   reuse_addr,
                       const void *act,
                       int   priority,
                       int   signal_number) = 0;

ACE_Asynch_Transmit_File_Impl ：在基类基础上添加了transmit_file

virtual int transmit_file (ACE_HANDLE file,
                             ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
                             size_t bytes_to_write,
                             u_long offset,
                             u_long offset_high,
                             size_t bytes_per_send,
                             u_long flags,
                             const void *act,
                             int priority,
                             int signal_number) = 0;

ACE_Asynch_Read_Dgram_Impl ：在基类基础上添加了recv

virtual ssize_t recv (ACE_Message_Block *message_block,
                        size_t &number_of_bytes_recvd,
                        int flags,
                        int protocol_family,
                        const void *act,
                        int priority,
                        int signal_number) = 0;

ACE_Asynch_Write_Dgram_Impl：在基类基础上添加了send

virtual ssize_t send (ACE_Message_Block *message_block,
                        size_t &number_of_bytes_sent,
                        int flags,
                        const ACE_Addr &addr,
                        const void *act,
                        int priority,
                        int signal_number) = 0;

ACE_Asynch_Result_Impl

ACE_Asynch_Read_Stream_Result_Impl：增加了bytes_to_read,message_block,handle

virtual size_t bytes_to_read (void) const = 0;
virtual ACE_Message_Block &message_block (void) const = 0;
virtual ACE_HANDLE handle (void) const = 0;

ACE_Asynch_Write_Stream_Result_Impl：增加了bytes_to_write,message_block,handle

virtual size_t bytes_to_write (void) const = 0;
virtual ACE_Message_Block &message_block (void) const = 0;
virtual ACE_HANDLE handle (void) const = 0;

ACE_Asynch_Accept_Result_Impl：增加了bytes_to_read,message_block, listen_handle,accept_handle

virtual size_t bytes_to_read (void) const = 0;
virtual ACE_Message_Block &message_block (void) const = 0;
virtual ACE_HANDLE listen_handle (void) const = 0;
virtual ACE_HANDLE accept_handle (void) const = 0;

ACE_Asynch_Connect_Result_Impl：增加了connect_handle

virtual ACE_HANDLE connect_handle (void) const = 0;

ACE_Asynch_Transmit_File_Result_Impl：增加了socket,file,header_and_trailer,bytes_to_write,bytes_per_send和flags

virtual ACE_HANDLE socket (void) const = 0;
virtual ACE_HANDLE file (void) const = 0;
virtual ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer (void) const = 0;
virtual size_t bytes_to_write (void) const = 0;
virtual size_t bytes_per_send (void) const = 0;
virtual u_long flags (void) const = 0;

ACE_Asynch_Read_Dgram_Result_Impl：增加了message_block,bytes_to_read,remote_address,flags和handle

virtual ACE_Message_Block *message_block (void) const = 0;
virtual size_t bytes_to_read (void) const = 0;
virtual int remote_address (ACE_Addr& addr) const = 0;
virtual int flags (void) const = 0;
virtual ACE_HANDLE handle (void) const = 0;

ACE_Asynch_Write_Dgram_Result_Impl：增加了message_block,bytes_to_write,flags和handle

virtual size_t bytes_to_write (void) const = 0;
virtual ACE_Message_Block *message_block (void) const = 0;
virtual int flags (void) const = 0;
virtual ACE_HANDLE handle (void) const = 0;

ACE_Proactor_Impl的实现类

异步类

异步操作子类

异步结果类

win32异步操作实现类子类

ACE_WIN32_Asynch_Operation ：包含了处理器，所属的Proactor以及对应的句柄，在发起操作时，会创建ACE_WIN32_Asynch_Result，同时将处理器传入

win32异步结果实现类子类

Posix异步操作实现类子类

ACE_POSIX_Asynch_Operation ：包含了处理器，所属的Proactor以及对应的句柄，在发起操作时，会创建ACE_POSIX_Asynch_Result，同时将处理器传入

Posix异步结果实现类子类

时序

使用的是Handler，其调用时序为

异步Acceptor-Connector框架

Acceptor的时序为
以window平台的为例

Connector的时序为
以window平台的为例

其异步connect是基于Reactor，依赖ACE_Asynch_Pseudo_Task，所以
ACE_POSIX_Asynch_Connect和ACE_WIN32_Asynch_Connect也继承ACE_Event_Handler
windows平台的连接没有使用win32下的异步connect
windows和linux平台都是通过Reactor来实现异步connect

ACE_Asynch_Pseudo_Task方法有

public:
	int start (void);
	int stop (void);
	
	int register_io_handler (ACE_HANDLE handle,ACE_Event_Handler *handler,ACE_Reactor_Mask mask,int flg_suspend);
	
	int remove_io_handler (ACE_HANDLE handle);
	int remove_io_handler (ACE_Handle_Set &set);
	int resume_io_handler (ACE_HANDLE handle);
	int suspend_io_handler (ACE_HANDLE handle);
protected:
	virtual int svc (void);