终于明白ACE_Event_Handler和ACE_Svc_Handler是怎么回事了

经过几天ACE的学习终于明白reactor,acceptor, ACE_Event_Handler,

ACE_Svc_Handler之间怎么回事了

 

//用来和svc handler对比
class My_Input_Handler: public ACE_Event_Handler
{
public:
        My_Input_Handler()
        {
                ACE_DEBUG((LM_DEBUG, "My_Input_Handler Constructor \n"));
        }
        //reactor回调input处理函数返回为0,保持处理,-1注销这个处理
        int handle_input(ACE_HANDLE)
        {
                //处理过程
                peer().recv_n(data, SIZE_BUF);
                ACE_DEBUG((LM_DEBUG, "recv data:%s\n", data));
                return 0;
        }
        //当从反应器注销的时候调用这个,在这里可以释放在自己管理范围内申请的内存
        virtual int handle_close(ACE_HANDLE handler, ACE_Reactor_Mask mask)
        {
                delete this;
        }
        //reactor底层需要的函数
        ACE_HANDLE get_handle() const
        {
                return this->peer_peer_stream().get_handle();
        }
        //reactor底层需要的函数,同时还能给accpetor使用
        ACE_SOCK_Stream &peer_stream()
        {
                return this->peer;
        }
       
private:
        ACE_SOCK_Stream peer;
        char data[SIZE_BUF];
};

/*
        ACE_SOCK_Stream 有流的能力
        ACE_NULL_SYNCH 单线程/ACE_MT_SYNCH多线程
       
       
*/
class My_Svc_Handler:public ACE_Svc_Handler<ACE_SOCK_Stream, ACE_MT_SYNCH>
{
public:
        My_Svc_Handler()
        {
                data = new char[SIZE_BUF];
        }
        //链接来的时候调用一下
        int open(void *)
        {
                // The two thread names are kept here
                ACE_thread_t thread_names[2];
                //注册reactor
                Reactor::instance()->register_handler(this, ACE_Event_Handler::READ_MASK);
                //启动线程
                activate(THR_NEW_LWP,
                        2, //  2 个线程
                        0, //force active false, if already created don’t try again.
                        ACE_DEFAULT_THREAD_PRIORITY,//Use default thread priority
                        -1,
                        this,//Which ACE_Task object to create? In this case this one.
                        0,// don’t care about thread handles used
                        0,// don’t care about where stacks are created
                        0,//don’t care about stack sizes
                        thread_names); // keep identifiers in thread_names
                return 0;
        }
        //处理read情况
        int handle_input(ACE_HANDLE)
        {
                //处理过程
                peer().recv_n(data, SIZE_BUF);
                ACE_DEBUG((LM_DEBUG, "recv data:%s\n", data));
                return 0;
        }
        //线程和线程之间可以通过ACE_Message_Block进行通信
        //SVC 实际线程调用函数
        int svc(void)
        {
                return 0;
        }
private:
         char *data;
};

class My_Accept_Handler: public ACE_Event_Handler
{
public:
        My_Accept_Handler(ACE_Addr &addr)
        {
               this->open(addr)
        }
        int open(ACE_Addr &addr)
        {
                peer_acceptor.open(addr)
        }
        //reactor回调input处理函数
        int handle_input(ACE_HANDLE)
        {
                ACE_INET_Addr client_addr;
                ACE_Time_Value timeout(ACE_DEFAULT_TIMEOUT);
                My_Input_Handler *peer_handler = new My_Input_Handler();
                if (this->peer_acceptor.accept(peer_handler->peer_stream(),
                        &client_addr,
                        &timeout,
                        1) == -1) {
                        ACE_DEBUG((LM_ERROR, "Error in connection\n"));
                }
                ACE_DEBUG((LM_DEBUG,
                        "Connection established with remote %s:%d\n",
                        client_addr.get_host_name(),
                        client_addr.get_port_number()));
                ACE_Reactor::instance()->register_handler(peer_handler, ACE_Event_Handler::READ_MASK);
                //每接收一次注销一下,不释放新客户端的注册
                return -1;
        }
        ACE_HANDLE get_handle() const
        {
                return this->peer_acceptor.get_handle();
        }
private:
        ACE_SOCK_Acceptor peer_acceptor;
};