REACTOR用法问题-信号处理

peakzhang

以下是一个测试ACE REACTOR的程序：                                                                     

1.                                                                                                       
2. #include "ace/Event_Handler.h"                                                                        
3. #include "ace/Reactor.h"                                                                              
4.                                                                                                       
5. #include <signal.h>                                                                                   
6.                                                                                                       
7. #include <iostream>                                                                                   
8.                                                                                                       
9. using namespace std ;                                                                                 
10.                                                                                                       
11. class QuitHandler : public ACE_Event_Handler                                                         
12. {                                                                                                     
13. public:                                                                                               
14.     QuitHandler( ACE_Reactor * r ) : ACE_Event_Handler( r )                                          
15.     {                                                                                                
16.     }                                                                                                
17.                                                                                                       
18.     int open( void )                                                                                 
19.     {                                                                                                
20.         return this->reactor()->register_handler(this, ACE_Event_Handler::EXCEPT_MASK);               
21.     }                                                                                                
22.                                                                                                       
23.     int handle_exception( ACE_HANDLE )                                                               
24.     {                                                                                                
25.         cout << "reactor()->end_reactor_event_loop()" << endl ;                                       
26.         reactor()->end_reactor_event_loop() ;                                                         
27.         return -1 ;                                                                                   
28.                                                                                                       
29.      }                                                                                                
30.                                                                                                       
31.     int handle_close( ACE_HANDLE, ACE_Reactor_Mask )                                                  
32.     {                                                                                                
33.         cout << "delete this in QuitHandler::handle_close()" << endl ;                                
34.         delete this ;                                                                                 
35.         return 0 ;                                                                                    
36.     }                                                                                                
37.                                                                                                       
38. } ;                                                                                                   
39.                                                                                                       
40. class MyEvent_Handler : public ACE_Event_Handler                                                      
41. {                                                                                                     
42. public:                                                                                               
43.     MyEvent_Handler( ACE_Reactor *r ) : ACE_Event_Handler( r )                                       
44.     {                                                                                                
45.     }                                                                                                
46.                                                                                                       
47.     int open( void )                                                                                 
48.     {                                                                                                
49.         return this->reactor()->register_handler(this, ACE_Event_Handler::SIGNAL_MASK);               
50.     }                                                                                                
51.                                                                                                       
52.     int handle_signal( int signum )                                                                  
53.     {                                                                                                
54.         cout << "catch a signal" << endl ;                                                            
55.                                                                                                       
56.         if( signum == SIGUSR1 || signum == SIGUSR2 )                                                  
57.         {                                                                                             
58.             ACE_Reactor *r = ACE_Reactor::instance() ;                                                
59.             QuitHandler *qhandler = new QuitHandler( r ) ;                                            
60.             qhandler->open() ;                                                                        
61.                                                                                                       
62.             r->notify( qhandler ) ;                                                                  
63.         }                                                                                             
64.                                                                                                       
65.         return -1 ;                                                                                   
66.     }                                                                                                
67.                                                                                                       
68.     int handle_close( ACE_HANDLE, ACE_Reactor_Mask )                                                  
69.     {                                                                                                
70.         delete this ;                                                                                 
71.         return 0 ;                                                                                    
72.     }                                                                                                
73. } ;                                                                                                   
74.                                                                                                       
75.                                                                                                       
76.                                                                                                       
77. int main()                                                                                            
78. {                                                                                                     
79.     cout << SIGUSR1 << " " << SIGUSR2 << endl ;                                                      
80.                                                                                                       
81.     MyEvent_Handler myhandler( ACE_Reactor::instance() ) ;                                            
82.     myhandler.open() ;                                                                                
83.                                                                                                       
84.     ACE_Reactor::instance()->run_reactor_event_loop() ;                                               
85.                                                                                                       
86.     return 0 ;                                                                                       
87. }                                                                                                     

复制代码

                                                                                                     
                                                                                                      
问题是，当我在命令行 发SIGUSR1 或 SIGUSR2信号给该程序时，程序并没有检测到信号发生，因而没有调用      
                                                                                                      
handle_signale HOOK METHOD。但是我已经在REACTOR上注册了的，不知道什么原因。请各位帮我看看，谢谢！

[ 本帖最后由 peakzhang 于 2007-12-11 22:19 编辑 ]

peakzhang

要加上

ACE_Reactor::instance()->register_handler(SIGUSR1,this);
ACE_Reactor::instance()->register_handler(SIGUSR2,this);

把这两个信号注册到REACTOR。