一动不如一静

/**/ /* *******************************************************************
* Copyright (c) 2006,study-record home
* All rights reservered.
*
* 文件名称 : littersize.cpp 
* 摘    要 : 这个例子主要是用来验证这样一个问题。当我们程序中有n个reactor的时候，是否就意味着我们支持n*FD_SETSIZE连接.
                   为了验证这个问题,我们传递一个大小为2的值给ACE_Select_Reactor的构造函数。看是否是只支持2个连接?
                   验证结果表明：在本例子中，由于acceptor注册用掉了一个，而我们给定的最大的handle数为2,所以只能接受一个连接。
                   在命令行下输入：telnet 127.0.0.1 1234 ,在我们第二次输入时，
                   在调用int nRet = m_Reactor->register_handler(pEvent, ACE_Event_Handler::READ_MASK);的时候一定会失败。
                   但是在命令行下输入:telnet 127.0.0.1 2345 ,在我们第三次输入的时候，调用register_handler的时候才会失败
                   但是这样的一段代码存在高cpu的问题，也就是当把客户端关调的时候，cpu占用率会很高?想想看，为什么呢？
                   本代码只是为了验证一些东西，有很多不合理的地方，请务仿照。
*
* 当前版本 : 1.0
* 作    者 : study-record   2007-2-22
*
******************************************************************** */

#include  " ace/Thread_Manager.h "
#include  " ace/Select_Reactor.h "
#include  " ace/Reactor.h "
#include  " ace/Event_Handler.h "
#include  " ace/SOCK_Acceptor.h "
#include  " ace/SOCK_Stream.h "
#include  " ace/INET_Addr.h "

const  size_t g_unOneMaxHandle  =   2 ;
const  size_t g_unTwoMaxhandle  =   4 ;


static  ACE_THR_FUNC_RETURN event_loop_one ( void   * arg) 
{
    ACE_Reactor  * reacator  =  static_cast < ACE_Reactor  *> (arg);

    reacator -> owner(ACE_Thread::self());
    reacator -> run_reactor_event_loop();
     return   0 ;

}
static  ACE_THR_FUNC_RETURN event_loop_two ( void   * arg) 
{
    ACE_Reactor  * reacator  =  static_cast < ACE_Reactor  *> (arg);

    reacator -> owner(ACE_Thread::self());
    reacator -> run_reactor_event_loop();
     return   0 ;
}

class  TestHandleEvent:  public  ACE_Event_Handler
{
public :
     virtual   int  handle_input (ACE_HANDLE fd  =  ACE_INVALID_HANDLE)
     {
        ACE_DEBUG((LM_DEBUG,  " TestHandleEvent::handle_input\n " ));
         return   0 ;
    } ;
     virtual   int  handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)
     {
        
        ACE_DEBUG((LM_DEBUG,  " TestHandleEvent::handle_close\n " ));
        delete  this ;
         return   0 ;

    } ;
    ACE_HANDLE get_handle( void )  const  
     {
         return  peer.get_handle();
    }

public :
    ACE_SOCK_Stream peer;

} ;
class  TestAcceptor :  public  ACE_Event_Handler
{
public :
     virtual   int  handle_input (ACE_HANDLE fd  =  ACE_INVALID_HANDLE)
     {
        
        TestHandleEvent *  pEvent  =   new  TestHandleEvent;
        acceptor.accept(pEvent -> peer);
         int  nRet  =  m_Reactor -> register_handler(pEvent, ACE_Event_Handler::READ_MASK);
         if  ( - 1   ==  nRet)
         {
            delete pEvent;
            pEvent  =  NULL;
        }

         return   0 ;
    } ;
     virtual   int  handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)
     {
        ACE_DEBUG((LM_DEBUG,  " TestAcceptor::handle_close\n " ));
        acceptor.close();
        delete  this ;

         return   0 ;

    } ;
    
    
    TestAcceptor(ACE_Reactor *  reactor):m_Reactor(reactor)
     {
        
    } ;
     int  open(unsigned  short  usport)
     {
        ACE_INET_Addr addr(usport);
        acceptor.open(addr);
         return  m_Reactor -> register_handler( this , ACE_Event_Handler::ACCEPT_MASK);

    } ;
    ACE_HANDLE get_handle( void )  const  
     {
        
         return  acceptor.get_handle();
    }
public :
    ACE_SOCK_Acceptor acceptor;
    ACE_Reactor *  m_Reactor;

} ;


int  main ( int  argc,  char   * argv[])
{
    

    ACE_Select_Reactor select_reactor_one(g_unOneMaxHandle,  0 ,  0 ,  0 ,  1 );
    ACE_Reactor *  reactor_one  =   new  ACE_Reactor( & select_reactor_one);

    ACE_Select_Reactor select_reactor_two(g_unTwoMaxhandle,  0 ,  0 ,  0 ,  1 );
    ACE_Reactor *  reactor_two  =   new  ACE_Reactor( & select_reactor_two);

    TestAcceptor test_acceptor(reactor_one);
    test_acceptor.open( 1234 );

    TestAcceptor test_acceptorw(reactor_two);
    test_acceptorw.open( 2345 );
    
    
    ACE_Thread_Manager::instance() -> spawn(event_loop_one, reactor_one);
    ACE_Thread_Manager::instance() -> spawn(event_loop_two, reactor_two);

     return  ACE_Thread_Manager::instance() -> wait();
}