C ++ processes kill and CTRL + C signals

1. From:
   Http://blog.csdn.net/xian0617/article/details/6689357
2. /*
3. * Waitquitsignal. h
4. *
5. * Created on: Aug 14,201 1
6. * Author: xian0617
7. */
9. # Ifndef waitquitsignal_h _
   
10. # Define waitquitsignal_h _
    
11. # Include <signal. h>
12. # Include <time. h>
    
13. Class waitquitsignal {
14. Public:
15. Static void Init ();
    
16. Static bool wait (bool & flag );
    
17. PRIVATE:
18. Static sigset_t m_wait_mask;
    
19. Static struct timespec m_time;
    
20. };
22. # Endif/* waitquitsignal_h _*/
    

/* <Br/> * waitquitsignal. h <br/> * created on: Aug 14,201 1 <br/> * Author: xian0617 <br/> */</P> <p> # ifndef waitquitsignal_h _ <br/> # define waitquitsignal_h _ <br/> # include <signal. h> <br/> # include <time. h> <br/> class waitquitsignal {<br/> Public: <br/> static void Init (); <br/> static bool wait (bool & flag ); <br/> PRIVATE: <br/> static sigset_t m_wait_mask; <br/> static struct timespec m_time; <br/> }; </P> <p> # endif/* waitquitsignal_h _ */<br/>

[CPP]
View plaincopyprint?

1. /*
2. * Waitquitsignal. cpp
3. *
4. * A thread in Linux is essentially a light weighted process. When a thread is generated, a corresponding process control structure is generated,
   
5. * This structure shares the same process memory space with the parent thread's process control structure. At the same time, the process control structure of the new thread will be from the parent thread (process)
   
6. * Obtain the same process information, such as opening the file list and blocking mask. Because we modified the signal blocking mask after the subthread was generated
   
7. * Code. At this moment, the subthread uses the original process information of the main thread. Therefore, the subthread will still respond to the SIGINT and sigterm signals. Therefore, when
   
8. * When we use Ctrl + C to send a SIGINT signal, the main process does not process the signal, and the sub-process (thread) performs default processing, that is, exit.
   
9. * When a child process exits, it sends a sigchld signal to the parent process (thread), indicating that the child process exits. Because the signal is not blocked
   
10. * The main process (thread) also exits immediately, and the preceding running condition occurs. Therefore, one solution to this problem is to set the signal before the subthread is generated,
    
11. * Set the signal within the subthread.
12. * Created on: Aug 14,201 1
13. * Author: xian0617
14. */
16. # Include <iostream>
17. # Include "waitquitsignal. H"
    
18. Sigset_t waitquitsignal: m_wait_mask;
19. Struct timespec waitquitsignal: m_time;
    
20. // Call this before thread create
    
21. Void waitquitsignal: Init (){
    
22. Try {
23. Signal (sigkill, sig_ign );
24. Sigemptyset (& m_wait_mask );
25. Sigaddset (& m_wait_mask, SIGINT );
26. Sigaddset (& m_wait_mask, sigquit );
27. Sigaddset (& m_wait_mask, sigterm );
28. Pthread_sigmask (sig_block, & m_wait_mask, 0 );
29. } Catch (STD: exception & E ){
    
30. STD: cerr <"exception:" <E. What () <STD: Endl;
    
31. }
32. M_time. TV _sec = 0;
33. M_time. TV _nsec = 0;
34. }
35. Bool waitquitsignal: Wait (bool & flag ){
    
36. Try {
37. Siginfo_t SIG;
38. Switch (sigtimedwait (& m_wait_mask, & Sig, & m_time )){
    
39. Case SIGINT:
40. Case sigquit:
41. Case sigterm:
    
42. Flag = false;
43. Break;
44. Default:
45. Break;
46. }
48. } Catch (STD: exception & E ){
    
49. STD: cerr <"exception:" <E. What () <STD: Endl;
    
50. }
51. Return flag;
52. }

/* <Br/> * waitquitsignal. CPP <br/> * in Linux, a thread is essentially a light weighted process. When a thread is generated, a corresponding process control structure is generated, <br/> * This structure shares the same process memory space with the parent thread's process control structure. At the same time, the process control structure of the new thread will copy the same process information from the parent thread (process) <br/> *, such as opening the file list and blocking mask. Because the signal blocking mask is modified after the subthread is generated <br/> * code, the subthread uses the original process information of the main thread, therefore, the sub-thread will still respond to the SIGINT and sigterm signals. Therefore, when <br/> * we use Ctrl + C to send a SIGINT signal, the main process will not process the signal, the sub-process (thread) performs default processing, that is, exit. <Br/> * when a child process exits, it sends a sigchld signal to the parent process (thread), indicating that the child process exits. Because the signal is not blocked, as a result, <br/> * The main process (thread) also exits immediately and the preceding running condition occurs. Therefore, one solution to this problem is to set the signal before the subthread is generated. <br/> * or set the signal inside the subthread. <Br/> * created on: Aug 14,201 1 <br/> * Author: xian0617 <br/> */</P> <p> # include <iostream> <br/> # include "waitquitsignal. H "<br/> sigset_t waitquitsignal: m_wait_mask; <br/> struct timespec waitquitsignal: m_time; <br/> // call this before thread create <br/> void waitquitsignal: Init () {<br/> try {<br/> signal (sigkill, sig_ign ); <br/> sigemptyset (& m_wait_mask); <br/> sigaddset (& m_wait_mask, SIGINT); <br/> sigaddset (& m_wait_mask, sigquit ); <br/> sigaddset (& m_wait_mask, sigterm); <br/> pthread_sigmask (sig_block, & m_wait_mask, 0); <br/>} catch (STD: exception & E) {<br/> STD: cerr <"exception:" <E. what () <STD: Endl; <br/>}< br/> m_time. TV _sec = 0; <br/> m_time. TV _nsec = 0; <br/>}< br/> bool waitquitsignal: Wait (bool & flag) {<br/> try {<br/> siginfo_t SIG; <br/> switch (sigtimedwait (& m_wait_mask, & Sig, & m_time) {<br/> case SIGINT: <br/> case sigquit: <br/> case sigterm: <br/> flag = false; <br/> break; <br/> default: <br/> break; <br/>}</P> <p>} catch (STD: exception & E) {<br/> STD: cerr <"exception: "<E. what () <STD: Endl; <br/>}< br/> return flag; <br/>}< br/>

Sample Model

[CPP]
View plaincopyprint?

1. Int main (INT argc, char ** argv ){
   
2. // Step 1 init
3. Waitquitsignal: Init ();
4. // Step 2 create subthread
   
6. // Step 3 Wait Signal
7. While (waitquitsignal: Wait (FLAG )){
   
8. Sleep (1 );
9. }
10. // Step 4 deal quit job
11. // Save ();
12. }

Int main (INT argc, char ** argv) {<br/> // Step1 init <br/> waitquitsignal: Init (); <br/> // step2 create subthread </P> <p> // Step3 wait signal <br/> while (waitquitsignal: Wait (FLAG )) {<br/> sleep (1); <br/>}< br/> // step4 deal quit job <br/> // save (); <br/>}