Linux下发送自定义信号 C++代码

luojiafeng1984

今天做的能够实现进程间发送自己定义的信号了,并且可以带参数。
不过发现没多大用处，因为Linux上留了 SIGRTMIN(32)到SIGRTMAX(64)等三十二个可靠信号，可以给应用程序用，基本上已经够用了。
如果用Linux的信号的话，也可以带参数，就是用 sigqueue函数来发送信号，这个函数只可以给一个进程发送信号。

今天做的思路变了一下，就是调用我自己的类的成员函数发送信号之前，我会利用Linux上的共享内在技术(shmget/shmat/shmdt等函数)，把要发送的自定义消息，以及所带的参数写到共享内存，然后接收信号的进程收到某个特定的信号之后，再去读共享内存，再把共享内存里面的参数信息交给用户自己定义的信号处理函数处理。



我在CSDN上看见有人问下面这样一个问题:
----------------------------------------------------------------------------------
标题:LINUX下的自定义信号如何实现（不使用系统的SIGUSR1和SIGUSR2)
内容:
（1）例如：   
  #define   SIG_MY_MSG   SIGUSR1+100   
  当我调用kill(0,SIG_MY_MSG）时，系统能够识别出SIG_MY_MSG信号。   
----------------------------------------------------------------------------------

有人说要改Linux内核,将信号的最大值64修改大一些，我不会改内核，写出下面的代码，来实现进程内的的自定义信号发送（进程间的自定义信号发送还得加代码），大家看还有更好的方法吗？拍砖一下，我对自己写的代码没自信，从来没有人看过我写的程序。

大概的思路是这样的：

1、进程里面有一个自定义的单件信号处理类
2、信号处理类里面有一个向量表，来保存用户安装的自定义信号和相应的信号处理函数
3、发送信号时，调用自己的信号发送函数，自己定义的信号发送函数会保存用户发送的信号的值

1. #include <iostream>
   
2. #include <sys/types.h>
   
3. #include <sys/params.h>
   
4. #include <signal.h>
   
5. #include <stdio.h>
   
6. #include <unistd.h>
   
7. #include <vector>
   
8. using namespace std;
   
9. 
   
10. #define MYSIG_MSG        SIGUSR1 + 2                        // 自定义的信号,类似于windows平台的 #define WM_MYMESSAGE        WM_USER + 2
    
11. #define MYSIG_MSG        SIGUSR1 + 3
    
12. #define MYSIG_MSG        SIGUSR1 + 4
    
13. #define MYSIG_MSG        SIGUSR1 + 5
    
14. 
    
15. void Handler_MSG(unsigned long sig)                // 自定义的信号处理函数,linux的信号处理函数的参数是int,我这里用unsigned long
    
16. {
    
17.         write( 2, "Handler_MSG\n", 12 );
    
18. }
    
19. 
    
20. void Handler_MSG2(unsigned long sig)
    
21. {
    
22.         write( 2, "Handler_MSG2\n", 13 );
    
23. }
    
24. 
    
25. void Handler_MSG3(unsigned long sig)
    
26. {
    
27.         write( 2, "Handler_MSG3\n", 13 );
    
28. }
    
29. 
    
30. void Handler_MSG4(unsigned long sig)
    
31. {
    
32.         write( 2, "Handler_MSG4\n", 13 );
    
33. }
    
34. 
    
35. class CSignalHandler                                        // 单件信号处理类,安装和发送自定义的信号都调用此类的成员函数
    
36. {
    
37. protected:
    
38.         typedef void (*SIG_HANDLER_PF)(unsigned long sig);                // 定义一个指向信号处理函数的指针
    
39.         struct tagSigaction                                                                                // 定义一个结构体,结构体的一个成员是自定义的信号,另一个成员是个处理自定义信号的函数的指针
    
40.         {
    
41.                 unsigned long m_ulSigNumber;
    
42.                 void (*m_Handler)(unsigned long sig);
    
43.         };
    
44.         typedef vector<tagSigaction>        SIGACTION_VECTOR;                // 自定义信号的结构体数组
    
45.         typedef SIGACTION_VECTOR::iterator SIGACTION_VECTOR_IT;// 迭代器类型,用来访问vector
    
46.         SIGACTION_VECTOR        m_SigactionVector;                                        //把自定义的信号及信号处理函数,用vector保存起来
    
47.         unsigned long m_ulCurrentSigNumber;                                                // 当前接收到的信号
    
48. 
    
49. protected:                                                                                                        // 构造函数定义成保护的,不让用户自己生成信号处理类对象,
    
50.         CSignalHandler()
    
51.         {
    
52.                 ActionDefaultSigHandler();
    
53.         }
    
54.         ~CSignalHandler()
    
55.         {
    
56.         }
    
57. 
    
58. public:
    
59.         static CSignalHandler* GetSignalHandler()                                // 获取信号处理类的全局访问点
    
60.         {
    
61.                 static CSignalHandler signalhandler;
    
62.                 return &signalhandler;
    
63.         }
    
64. 
    
65. protected:
    
66. // 当用户发送一个自定义的信号的时候,该函数就会被调用,然后根据用户发送的信号,调用用户设置的函数进行处理
    
67. 
    
68.         static void CustomSigHandler(int sig)                                               
    
69. {
    
70.                 SIGACTION_VECTOR& SigactionVector = CSignalHandler::GetSignalHandler()->GetSigActionVector();
    
71.                 SIGACTION_VECTOR_IT it;
    
72.                 for ( it = SigactionVector.begin(); it != SigactionVector.end(); it++ )
    
73.                 {
    
74.                         if ( (*it).m_ulSigNumber == CSignalHandler::GetSignalHandler()->GetCurrentSigNumber() )
    
75.                         {
    
76.                                 (*it).m_Handler( CSignalHandler::GetSignalHandler()->GetCurrentSigNumber() );
    
77.                         }
    
78.                 }
    
79.         }
    
80. 
    
81.         void ActionDefaultSigHandler()                                                        // 安装默认的SIGUSR1信号处理函数
    
82.         {
    
83.                 struct sigaction act;
    
84.                 act.sa_handler = CSignalHandler::CustomSigHandler;
    
85.                 sigemptyset(&act.sa_mask);
    
86.                 act.sa_flags = 0;
    
87.                 assert( sigaction(SIGUSR1, &act, NULL) >= 0 );
    
88.         }
    
89. 
    
90.         unsigned long GetCurrentSigNumber() const                                // 获取当前发送的信号
    
91.         {
    
92.                 return m_ulCurrentSigNumber;
    
93.         }
    
94. 
    
95.         void SetCurrentSigNumber(unsigned long ulCurrentSigNumber)        // 当用户发送一个信号时,先设置信号值
    
96.         {
    
97.                 m_ulCurrentSigNumber = ulCurrentSigNumber;
    
98.         }
    
99. 
    
100.         SIGACTION_VECTOR& GetSigActionVector()                                // 获取用户安装的信号vector的引用
     
101.         {
     
102.                 return m_SigactionVector;
     
103.         }
     
104. 
     
105.         int Raise(unsigned long ulSig)                                                // 发送自定义的信号
     
106.         {
     
107.                 m_ulCurrentSigNumber = ulSig;                                       
     
108.                 return raise(SIGUSR1);
     
109.         }
     
110. 
     
111.         void Sigaction(unsigned long sig, SIG_HANDLER_PF pf)        // 安装自定义的信号
     
112.         {
     
113.                 struct tagSigaction sigact;
     
114.                 sigact.m_ulSigNumber = sig;
     
115.                 sigact.m_Handler = pf;
     
116.                 m_SigactionVector.push_back(SIGACTION_VECTOR::value_type(sigact));
     
117.         }
     
118. 
     
119. };
     
120. 
     
121. int main(int argc, char* argv[])
     
122. {
     
123.         CSignalHandler::GetSignalHandler()->Sigaction( MYSIG_MSG, Handler_MSG);                        // 安装自定义的信号
     
124.         CSignalHandler::GetSignalHandler()->Sigaction( MYSIG_MSG2, Handler_MSG2);
     
125.         CSignalHandler::GetSignalHandler()->Sigaction( MYSIG_MSG3, Handler_MSG3);
     
126.         CSignalHandler::GetSignalHandler()->Sigaction( MYSIG_MSG4, Handler_MSG4);
     
127. 
     
128.         CSignalHandler::GetSignalHandler()->Raise(MYSIG_MSG);        // 发送自定义的信号
     
129.         CSignalHandler::GetSignalHandler()->Raise(MYSIG_MSG2);
     
130.         CSignalHandler::GetSignalHandler()->Raise(MYSIG_MSG3);
     
131.         CSignalHandler::GetSignalHandler()->Raise(MYSIG_MSG4);
     
132. 
     
133.         while (1)
     
134.         {
     
135.                 sleep(1);
     
136.         }
     
137.         return 0;
     
138. }

复制代码

[ 本帖最后由 luojiafeng1984 于 2007-9-13 17:46 编辑 ]

flw2

你这类貌似只能给进程自己发呀

luojiafeng1984

原帖由 flw2 于 2007-9-11 19:13 发表
你这类貌似只能给进程自己发呀

是这样的，我上面写清楚了，只能给进程自己发。
要实现给其他进程发，可能还需要靠进程通信来实现。有时间我试着做一下。
这些日子在公司闲着没事干。

为什么我发贴，代码断没颜色呢，奇怪了。

wu_pang_zi

兄弟，你误导了大家。
#define MYSIG_MSG        SIGUSR1 + 2                     
#define WM_MYMESSAGE        WM_USER + 2
#define MYSIG_MSG        SIGUSR1 + 3
#define MYSIG_MSG        SIGUSR1 + 4
#define MYSIG_MSG        SIGUSR1 + 5
你所定义的，刚好都是在信号集范围内的，如果你定义一个
#define MYSIG_MSG        SIGUSR1 + 100
这样，你就不会收到任何的信号。

醉卧水云间

看起来没啥用。

luojiafeng1984

原帖由 wu_pang_zi 于 2007-11-19 17:56 发表
兄弟，你误导了大家。
#define MYSIG_MSG        SIGUSR1 + 2                     
#define WM_MYMESSAGE        WM_USER + 2
#define MYSIG_MSG        SIGUSR1 + 3
#define MYSIG_MSG        SIGUSR1 + ...

没有啊,可能是我写的程序太乱了,因为是在虚拟机下搞的,我不知道怎么把文件下载到真实的机子上,
定义 SIGUSER + 100是可以的,我这个
发送自定义的信号时就是先发一个 SIGUSER1信号,把自定义的信号值作为参数用共享内存传过去.

不过就如那位兄弟所说,的确是没啥用,一般情况下,Linux的那些信号已经够用了.