实现一个可限制最大连接数的Proactor服务器

在服务器程序实现中，一般要求能够限制服务器的最大连接数，这主要是从服务器的性能方面考虑，当过多的连接到来时，服务器虽然能够处理，但效率非常低下，也就会出现卡机的现象。

 

在用Proactor框架实现的服务器中可以很容易地做到这一点。ACE_Asynch_Acceptor类有一个虚方法：make_handler()，默认情况下是new一个服务处理对象出来，我们可以让他在适当的时候返回一个空值，这样，新的连接便被拒绝了。

 

另外为了避免每次都完全构造一个全新的服务处理对象，这里还可以使用预分配的方法，一开始便创建出所有的service对象，当有连接到来时，直接取一个未使用的分配给该连接，当连接关闭时，同时也不delete该对象，而是加到空闲队列中，等下一次有新连接到来时再使用。

 

实现的代码如下：

#include <ace/Os_main.h>
#include <ace/Asynch_Acceptor.h>
#include <ace/Proactor.h>
#include <list>
 
#define LISTEN_PORT 5222              // 服务器监听端口
#define MAX_CONNS 2                     // 最大连接数
 
class HA_Proactive_Acceptor;
 
class HA_Proactive_Service : public ACE_Service_Handler
{
public:
       virtual ~HA_Proactive_Service ();
 
       void init( HA_Proactive_Acceptor * acceptor );
 
       virtual void open (ACE_HANDLE h, ACE_Message_Block&);
       virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
       virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
 
private:
       ACE_Asynch_Read_Stream reader_;
       ACE_Asynch_Write_Stream writer_;
 
       HA_Proactive_Acceptor * acceptor_;
};
 
 
class HA_Proactive_Acceptor : public ACE_Asynch_Acceptor<HA_Proactive_Service>
{
public:
       HA_Proactive_Acceptor();
 
       void free_handler( HA_Proactive_Service * service );
 
private:
       virtual HA_Proactive_Service *make_handler (void);
       void init_handlers();
 
private:
       typedef std::list<HA_Proactive_Service *> T_Handler_List;
       T_Handler_List handler_list_;
};
 
 
HA_Proactive_Service::~HA_Proactive_Service ()
{
       if (this->handle () != ACE_INVALID_HANDLE)
              ACE_OS::closesocket (this->handle ());
}
 
void HA_Proactive_Service::init( HA_Proactive_Acceptor * acceptor )
{
       this->acceptor_ = acceptor;
}
 
void HA_Proactive_Service::open (ACE_HANDLE h, ACE_Message_Block&)
{
       this->handle (h);
       if (this->reader_.open (*this) != 0 || this->writer_.open (*this) != 0   )
       {
              ACE_OS::closesocket (this->handle ());
              this->acceptor_->free_handler( this );
              return;
       }
 
       ACE_Message_Block *mb;
       ACE_NEW_NORETURN (mb, ACE_Message_Block (1024));
       if (this->reader_.read (*mb, mb->space ()) != 0)
       {
              mb->release ();
              ACE_OS::closesocket (this->handle ());
              this->acceptor_->free_handler( this );
       }
}
 
void HA_Proactive_Service::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
       ACE_Message_Block &mb = result.message_block ();
       if (!result.success () || result.bytes_transferred () == 0)
       {
              mb.release ();
              ACE_OS::closesocket (this->handle ());
              this->acceptor_->free_handler( this );
       }
       else
       {
              ACE_DEBUG ((LM_DEBUG, ACE_TEXT("Received Data : %c/n"), *mb.rd_ptr()));
              mb.release();
 
              ACE_Message_Block *new_mb;
              ACE_NEW_NORETURN (new_mb, ACE_Message_Block (1024));
              this->reader_.read (*new_mb, new_mb->space ());
       }
}
 
void HA_Proactive_Service::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
{
       result.message_block ().release ();
}
 
 
HA_Proactive_Acceptor::HA_Proactive_Acceptor() : ACE_Asynch_Acceptor<HA_Proactive_Service>()
{
       init_handlers();
}
 
void HA_Proactive_Acceptor::free_handler( HA_Proactive_Service * service )
{
       this->handler_list_.push_back( service );
}
 
HA_Proactive_Service * HA_Proactive_Acceptor::make_handler (void)
{
       if( this->handler_list_.empty() )
              return 0;
 
       HA_Proactive_Service * service = this->handler_list_.front();
       this->handler_list_.pop_front();
 
       return service;
}
 
void HA_Proactive_Acceptor::init_handlers()
{
       for( int i = 0; i < MAX_CONNS; ++i )
       {
              HA_Proactive_Service * service;
              ACE_NEW( service, HA_Proactive_Service );
              service->init( this );
              this->handler_list_.push_back( service );
       }
}
 
 
int ACE_TMAIN (int, ACE_TCHAR *[])
{
       ACE_INET_Addr listen_addr( LISTEN_PORT );
       HA_Proactive_Acceptor aio_acceptor;
       if (0 != aio_acceptor.open (listen_addr, 0, 0, 5, 1, 0, 0))
              ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p/n"), ACE_TEXT ("acceptor open")), 1);
 
       ACE_Proactor::instance ()->proactor_run_event_loop ();
 
       return 0;
}

转帖：http://blog.csdn.net/lfhfut/article/details/943532