ACE_linux：Reactor与Proactor两种模式的区别

一、概念：

Reactor与Proactor两种模式的区别。这里我们只关注read操作，因为write操作也是差不多的。下面是Reactor的做法：

1. 某个事件处理器宣称它对某个socket上的读事件很感兴趣；

2. 事件分离者等着这个事件的发生；

3. 当事件发生了，事件分离器被唤醒，这负责通知先前那个事件处理器；

4. 事件处理器收到消息，于是去那个socket上读数据了. 如果需要，它再次宣称对这个socket上的读事件感兴趣，一直重复上面的步骤；

下面再来看看真正意义的异步模式Proactor是如何做的：

1. 事件处理器直接投递发一个读操作(当然，操作系统必须支持这个异步操作)。这个时候，事件处理器根本不关心读事件，它只管发这么个请求，它魂牵梦萦的是这个读操作的完成事件。这个事件处理器很拽，发个命令就不管具体的事情了，只等着别人（系统）帮他搞定的时候给他回个话。

2. 事件分离器等着这个读事件的完成(比较下与Reactor的不同);

3. 当事件分离器默默等待完成事情到来的同时，操作系统已经在一边开始干活了，它从目标读取数据，放入用户提供的缓存区中，最后通知事件分离器，这个事情我搞完了;

4. 事件分离器通知之前的事件处理器: 你吩咐的事情搞定了;

5. 事件处理器这时会发现想要读的数据已经乖乖地放在他提供的缓存区中，想怎么处理都行了。如果有需要，事件处理器还像之前一样发起另外一个读操作，和上面的几个步骤一样。

二、代码示例：

ACE_Proactor::run_event_loop();  循环启动
ACE_Proactor::end_event_loop();  循环停止

-----------------------------------

Reactor：

-----------------------------------

-----------------------------------

Proactor：

 #include "ace/Proactor.h"
 #include "ace/Asynch_Acceptor.h"

 class HA_Proactive_Service : public ACE_Service_Handler
 {
 public:
     HA_Proactive_Service()
     {
         ACE_OS::printf("Service_Handler constructed for accepter \n");
     }
     ~HA_Proactive_Service ()
     {
         if (this->handle () != ACE_INVALID_HANDLE)
         {
             ACE_OS::closesocket (this->handle ());
         }
     }

     virtual void open (ACE_HANDLE h, ACE_Message_Block&)
     {
         //在OPEN函数中完成读写操作
         this->handle (h);
         if (this->reader_.open (*this) !=  ||
                 this->writer_.open (*this) !=    )
         {
             ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
                         ACE_TEXT ("HA_Proactive_Service open")));

             return;
         }
         ACE_OS::printf("ready!\n");

         //异步发送
         send_to_remote();
         //异步读取
         reveive_from_remote();

         // mb is now controlled by Proactor framework.
         return;
     }

     //异步读完成后会调用此函数
     virtual void handle_read_stream
     (const ACE_Asynch_Read_Stream::Result &result)
     {
         ACE_Message_Block &mb = result.message_block ();
         if (!result.success () || result.bytes_transferred () == )
         {
             mb.release ();

             return;
         }
         //else
         //输出读取内容
         ACE_OS::printf("received:%s\n",mb.rd_ptr());
         mb.release();
         //继续下一次异步读取
         reveive_from_remote();

         return;
     }
     //异步写完成后会调用此函数
     virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
     {
         result.message_block ().release();
         ACE_OS::sleep();
         //上次发送完毕之后再接着发送一次,这次发送完成之后又会调用
         //handle_write_stream，所以会一直发送
         send_to_remote();
         return;
     }
     //remote
     void reveive_from_remote(void)
     {
         ACE_Message_Block *mb;
         ACE_NEW_NORETURN (mb, ACE_Message_Block ());
         if (this->reader_.read (*mb, mb->space ()) != )
         {
             ACE_OS::printf("Begin read fail\n");

             return;
         }
     }
     //把当前时间发送到远端
     void send_to_remote(void)
     {
         std::string book = "S: ";
         time_t now = ACE_OS::gettimeofday().sec();
         book = book+ ctime(&now);
         ACE_Message_Block *mb = new ACE_Message_Block();
         //获取当前时间的字符串格式
         mb->copy(book.c_str() );
         //send message to accepter
         if (this->writer_.write(*mb,mb->length()) !=)
         {
             ACE_OS::printf("Begin write fail\n");

             return;
         }
         else
         {
             ACE_OS::printf("sended %s\n",mb->rd_ptr());
         }
     }

     // Listing 3
 private:
     ACE_Asynch_Read_Stream reader_;
     ACE_Asynch_Write_Stream writer_;
 };

 int main(int argc, char *argv[])
 {
     int port=;
     ACE_Asynch_Acceptor<HA_Proactive_Service> acceptor;

     if (acceptor.open (ACE_INET_Addr (port)) == -)
         return -;

     while(true)
         ACE_Proactor::instance ()->handle_events ();

     return ;
 }

Acceptor.cpp

 #include "ace/Proactor.h"
 #include "ace/Asynch_Connector.h"

 class HA_Proactive_Service : public ACE_Service_Handler
 {
 public:
     HA_Proactive_Service()
     {
         ACE_OS::printf("Service_Handler constructed for connector \n");
     }
     ~HA_Proactive_Service ()
     {
         if (this->handle () != ACE_INVALID_HANDLE)
         {
             ACE_OS::closesocket (this->handle ());
         }
     }

     virtual void open (ACE_HANDLE h, ACE_Message_Block&)
     {
         //在OPEN函数中完成读写操作
         this->handle (h);

         if (this->reader_.open (*this) !=  ||
                 this->writer_.open (*this) !=    )
         {
             ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
                         ACE_TEXT ("HA_Proactive_Service open")));

             return;
         }

         ACE_OS::printf("connceted!\n");
         //异步发送
         send_to_remote();
         //异步读取
         reveive_from_remote();

         return;
     }

     //异步读完成后会调用此函数
     virtual void handle_read_stream
     (const ACE_Asynch_Read_Stream::Result &result)
     {
         ACE_Message_Block &mb = result.message_block ();
         if (!result.success () || result.bytes_transferred () == )
         {
             mb.release ();

             return;
         }
         //else
         //输出读取内容
         ACE_OS::printf("received:%s\n",mb.rd_ptr());
         mb.release();
         //继续下一次异步读取
         reveive_from_remote();

         return;
     }
     //异步写完成后会调用此函数
     virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
     {
         result.message_block ().release();
         ACE_OS::sleep();
         //上次发送完毕之后再接着发送一次,这次发送完成之后又会调用
         //handle_write_stream，所以会一直发送
         send_to_remote();
         return;
     }
     //remote
     void reveive_from_remote(void)
     {
         ACE_Message_Block *mb;
         ACE_NEW_NORETURN (mb, ACE_Message_Block ());
         if (this->reader_.read (*mb, mb->space ()) != )
         {
             ACE_OS::printf("Begin read fail\n");

             return;
         }
     }
     //把当前时间发送到远端
     void send_to_remote(void)
     {
         std::string book = "C: ";
         time_t now = ACE_OS::gettimeofday().sec();
         book = book+ ctime(&now);
         ACE_Message_Block *mb = new ACE_Message_Block();
         //获取当前时间的字符串格式
         mb->copy(book.c_str() );
         //send message to accepter
         if (this->writer_.write(*mb,mb->length()) !=)
         {
             ACE_OS::printf("Begin write fail\n");

             return;
         }
         else
         {
             ACE_OS::printf("sended %s\n",mb->rd_ptr());
         }
     }

     // Listing 3
 private:
     ACE_Asynch_Read_Stream reader_;
     ACE_Asynch_Write_Stream writer_;
 };

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

     ACE_INET_Addr addr(,"127.0.0.1"); 

     ACE_Asynch_Connector<HA_Proactive_Service> connector;

     connector.open();
     if (connector.connect(addr) == -)
         return -;

     while(true)
         ACE_Proactor::instance ()->handle_events ();

     return ;
 }

Connector.cpp

ACE_Proactor::run_event_loop(); <==>
while(true)
    ACE_Proactor::instance ()->handle_events ();

//增加线程池

 #include "ace/Proactor.h"
 #include "ace/Asynch_Acceptor.h"
 #include "ace/Task_T.h"
 #include "ace/Thread_Semaphore.h"

 class Receive : public ACE_Service_Handler
 {
 public:
     Receive()
     {
         ACE_OS::printf("Service_Handler constructed for accepter \n");
     }
     ~Receive ()
     {
         if (this->handle () != ACE_INVALID_HANDLE)
         {
             ACE_OS::closesocket (this->handle ());
         }
     }

     virtual void open (ACE_HANDLE h, ACE_Message_Block&)
     {
         //在OPEN函数中完成读写操作
         this->handle (h);
         if (this->reader_.open (*this) !=  ||
                 this->writer_.open (*this) !=    )
         {
             ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
                         ACE_TEXT ("Receive open")));

             return;
         }
         ACE_OS::printf("ready!\n");

         //异步发送
         //send_to_remote();
         //异步读取
         reveive_from_remote();

         // mb is now controlled by Proactor framework.
         return;
     }

     //异步读完成后会调用此函数
     virtual void handle_read_stream
     (const ACE_Asynch_Read_Stream::Result &result)
     {
         ACE_Message_Block &mb = result.message_block ();
         if (!result.success () || result.bytes_transferred () == )
         {
             mb.release ();

             return;
         }

         //输出读取内容
         //ACE_OS::printf("received:%s\n",mb.rd_ptr());
         ACE_DEBUG((LM_DEBUG,"(%t)received:%s\n",mb.rd_ptr()));
         mb.release();

         //继续下一次异步读取
         reveive_from_remote();

         return;
     }
     //异步写完成后会调用此函数
     virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
     {
         result.message_block ().release();
         ACE_OS::sleep();
         //上次发送完毕之后再接着发送一次,这次发送完成之后又会调用
         //handle_write_stream，所以会一直发送
         send_to_remote();
         return;
     }
     //remote
     void reveive_from_remote(void)
     {
         ACE_Message_Block *mb;
         ACE_NEW_NORETURN (mb, ACE_Message_Block ());
         if (this->reader_.read (*mb, mb->space ()) != )
         {
             ACE_OS::printf("Begin read fail\n");

             return;
         }
     }
     //把当前时间发送到远端
     void send_to_remote(void)
     {
         std::string book = "S: ";
         time_t now = ACE_OS::gettimeofday().sec();
         book = book+ ctime(&now);
         ACE_Message_Block *mb = new ACE_Message_Block();
         //获取当前时间的字符串格式
         mb->copy(book.c_str() );
         //send message to accepter
         if (this->writer_.write(*mb,mb->length()) !=)
         {
             ACE_OS::printf("Begin write fail\n");

             return;
         }
         else
         {
             ACE_OS::printf("sended %s\n",mb->rd_ptr());
         }
     }

     // Listing 3
 private:
     ACE_Asynch_Read_Stream reader_;
     ACE_Asynch_Write_Stream writer_;
 };

 class Accepte : public ACE_Asynch_Acceptor<Receive>
 {
 public:
     virtual Receive* make_handler(void)
     {
         return new Receive();
     }

 };

 class Proactor_Task : public ACE_Task<ACE_MT_SYNCH>
 {
 public:

     int star(int nMax)
     {
         create_proactor();
         this->activate (THR_NEW_LWP, nMax);
         for (;nMax>;nMax--)
         {
             sem_.acquire();
         }
         return ;
     }
     int stop()
     {
         ACE_Proactor::end_event_loop();
         this->wait();
         return ;
     }

     virtual int svc (void)
     {
         ACE_DEBUG((LM_INFO,ACE_TEXT("svc method is invoked!\n")));
         sem_.release();

         ACE_Proactor::run_event_loop();

         return ;
     }

     int create_proactor()
     {
         ACE_Proactor::instance ();

         return ;
     }

     int release_proactor()
     {
         ACE_Proactor::close_singleton ();
         return ;
     }

     ACE_Thread_Semaphore sem_;
 };

 int ACE_TMAIN(int ,char*[])
 {
     Proactor_Task task;
     task.star();

     Accepte accepte;
     accepte.open(ACE_INET_Addr (), , ,ACE_DEFAULT_BACKLOG,,ACE_Proactor::instance());

     //主函数退出控制
     {
         int nExit=;
         while (nExit==)
             scanf("%d",&nExit);
     }

     return ;
 }

 /*
 int main(int argc, char *argv[])
 {
     int port=3000;
     ACE_Asynch_Acceptor<Receive> acceptor;

     if (acceptor.open (ACE_INET_Addr (port)) == -1)
         return -1;

     ACE_Proactor::run_event_loop();

     return 0;
 }
 */

Proactor_Task.cpp

-----------------------------------

GOOD LUCK!