为什么这里直接跳过了！！

devel

#include <unistd.h>
#include <signal.h>
#include <stdio.h>
int main(void)
{
  sigset_t    intmask;
  sigemptyset(&intmask);
  sigaddset(&intmask,SIGALRM);
  raise(SIGALRM);
  sigprocmask(SIG_BLOCK,&intmask,NULL);
  sleep (5);
  sigprocmask(SIG_UNBLOCK,&intmask,NULL);
  pause();
  exit(0);
}
这个程序并没有sleep 5 second .
怎么能产生一个信号而继续执行下面的程序，能不能先把这个信号储存起来，要的时候再释放出来？:help :thanks

x11

这是因为你没有安装SIGALRM的处理函数吧，进程就直接退出了

_z_

系统对SIGALRM的默认处理方法是终止进程
你自己写个处理函数就可以了

devel

#include <unistd.h>
#include <signal.h>
#include <stdio.h>
int main(void)
{
sigset_t intmask;
sigemptyset(&intmask);
sigaddset(&intmask,SIGALRM);
raise(SIGALRM);
sigprocmask(SIG_BLOCK,&intmask,NULL);
signal(SIGALRM,SIG_IGN); /* ignore the SIGALRM */
sleep (5);
sigprocmask(SIG_UNBLOCK,&intmask,NULL);
pause();
exit(0);
}
上面已忽略了sigalrm怎么还是同样的结果？

devel

觉得例子太少了。我贴些例程在这里，方便大家学习！！
come from:
http://www-900.ibm.com/developer ... /part2/index2.shtml

1. 
   
2. linux下的信号应用并没有想象的那么恐怖，程序员所要做的最多只有三件事情：
   
3. 
   
4.    1. 安装信号（推荐使用sigaction()）；
   
5.    2. 实现三参数信号处理函数，handler(int signal,struct siginfo *info, void *)；
   
6.    3. 发送信号，推荐使用sigqueue()。
   
7. 
   
8. 实际上，对有些信号来说，只要安装信号就足够了（信号处理方式采用缺省或忽略）。其他可能要做的无非是与信号集相关的几种操作。
   
9. 
   
10. 实例一：信号发送及处理
    
11. 实现一个信号接收程序sigreceive（其中信号安装由sigaction（））。
    
12. 
    
13. #include <signal.h>
    
14. #include <sys/types.h>
    
15. #include <unistd.h>
    
16. void new_op(int,siginfo_t*,void*);
    
17. int main(int argc,char**argv)
    
18. {
    
19.         struct sigaction act;       
    
20.         int sig;
    
21.         sig=atoi(argv[1]);
    
22.        
    
23.         sigemptyset(&act.sa_mask);
    
24.         act.sa_flags=SA_SIGINFO;
    
25.         act.sa_sigaction=new_op;
    
26.        
    
27.         if(sigaction(sig,&act,NULL) < 0)
    
28.         {
    
29.                 printf("install sigal error\n");
    
30.         }
    
31.        
    
32.         while(1)
    
33.         {
    
34.                 sleep(2);
    
35.                 printf("wait for the signal\n");
    
36.         }
    
37. }
    
38. void new_op(int signum,siginfo_t *info,void *myact)
    
39. {
    
40.         printf("receive signal %d", signum);
    
41.         sleep(5);
    
42. }
    
43. 
    
44. 说明，命令行参数为信号值，后台运行sigreceive signo &，可获得该进程的ID，假设为pid，然后再另一终端上运行kill -s signo pid验证信号的发送接收及处理。同时，可验证信号的排队问题。
    
45. 注：可以用sigqueue实现一个命令行信号发送程序sigqueuesend，见附录1。
    
46. 
    
47. 实例二：信号传递附加信息
    
48. 主要包括两个实例：
    
49. 
    
50.    1. 向进程本身发送信号，并传递指针参数；
    
51. 
    
52. #include <signal.h>
    
53. #include <sys/types.h>
    
54. #include <unistd.h>
    
55. void new_op(int,siginfo_t*,void*);
    
56. int main(int argc,char**argv)
    
57. {
    
58.         struct sigaction act;       
    
59.         union sigval mysigval;
    
60.         int i;
    
61.         int sig;
    
62.         pid_t pid;               
    
63.         char data[10];
    
64.         memset(data,0,sizeof(data));
    
65.         for(i=0;i < 5;i++)
    
66.                 data[i]='2';
    
67.         mysigval.sival_ptr=data;
    
68.        
    
69.         sig=atoi(argv[1]);
    
70.         pid=getpid();
    
71.        
    
72.         sigemptyset(&act.sa_mask);
    
73.         act.sa_sigaction=new_op;//三参数信号处理函数
    
74.         act.sa_flags=SA_SIGINFO;//信息传递开关
    
75.         if(sigaction(sig,&act,NULL) < 0)
    
76.         {
    
77.                 printf("install sigal error\n");
    
78.         }
    
79.         while(1)
    
80.         {
    
81.                 sleep(2);
    
82.                 printf("wait for the signal\n");
    
83.                 sigqueue(pid,sig,mysigval);//向本进程发送信号，并传递附加信息
    
84.         }
    
85. 
    
86. }
    
87. 
    
88. void new_op(int signum,siginfo_t *info,void *myact)//三参数信号处理函数的实现
    
89. {
    
90.         int i;
    
91.         for(i=0;i<10;i++)
    
92.         {
    
93.                 printf("%c\n ",(*( (char*)((*info).si_ptr)+i)));
    
94.         }
    
95.         printf("handle signal %d over;",signum);
    
96. }
    
97. 
    
98. 
    
99.       这个例子中，信号实现了附加信息的传递，信号究竟如何对这些信息进行处理则取决于具体的应用。
    
100.    2. 2、 不同进程间传递整型参数：把1中的信号发送和接收放在两个程序中，并且在发送过程中传递整型参数。
     
101.       信号接收程序：
     
102. 
     
103. #include <signal.h>
     
104. #include <sys/types.h>
     
105. #include <unistd.h>
     
106. void new_op(int,siginfo_t*,void*);
     
107. int main(int argc,char**argv)
     
108. {
     
109.         struct sigaction act;
     
110.         int sig;
     
111.         pid_t pid;               
     
112.        
     
113.         pid=getpid();
     
114.         sig=atoi(argv[1]);       
     
115.        
     
116.         sigemptyset(&act.sa_mask);
     
117.         act.sa_sigaction=new_op;
     
118.         act.sa_flags=SA_SIGINFO;
     
119.         if(sigaction(sig,&act,NULL)<0)
     
120.         {
     
121.                 printf("install sigal error\n");
     
122.         }
     
123.         while(1)
     
124.         {
     
125.                 sleep(2);
     
126.                 printf("wait for the signal\n");
     
127.         }
     
128. 
     
129. }
     
130. void new_op(int signum,siginfo_t *info,void *myact)
     
131. {
     
132.         printf("the int value is %d \n",info->si_int);
     
133. }
     
134. 
     
135. 
     
136.       信号发送程序：命令行第二个参数为信号值，第三个参数为接收进程ID。
     
137. 
     
138. #include <signal.h>
     
139. #include <sys/time.h>
     
140. #include <unistd.h>
     
141. #include <sys/types.h>
     
142. main(int argc,char**argv)
     
143. {
     
144.         pid_t pid;
     
145.         int signum;
     
146.         union sigval mysigval;
     
147. 
     
148.         signum=atoi(argv[1]);
     
149.         pid=(pid_t)atoi(argv[2]);
     
150.         mysigval.sival_int=8;//不代表具体含义，只用于说明问题
     
151. 
     
152.         if(sigqueue(pid,signum,mysigval)==-1)
     
153.                 printf("send error\n");
     
154.         sleep(2);
     
155. }
     
156. 
     
157. 
     
158.       注：实例2的两个例子侧重点在于用信号来传递信息，目前关于在linux下通过信号传递信息的实例非常少，倒是Unix下有一些，但传递的基本上都是关于传递一个整数，传递指针的我还没看到。我一直没有实现不同进程间的指针传递（实际上更有意义），也许在实现方法上存在问题吧，请实现者email我。
     
159. 
     
160. 实例三：信号阻塞及信号集操作
     
161. 
     
162. #include "signal.h"
     
163. #include "unistd.h"
     
164. static void my_op(int);
     
165. main()
     
166. {
     
167.         sigset_t new_mask,old_mask,pending_mask;
     
168.         struct sigaction act;
     
169. 
     
170.         sigemptyset(&act.sa_mask);
     
171.         act.sa_flags=SA_SIGINFO;
     
172.         act.sa_sigaction=(void*)my_op;
     
173.         if(sigaction(SIGRTMIN+10,&act,NULL))
     
174.                 printf("install signal SIGRTMIN+10 error\n");
     
175. 
     
176.         sigemptyset(&new_mask);
     
177.         sigaddset(&new_mask,SIGRTMIN+10);
     
178.         if(sigprocmask(SIG_BLOCK, &new_mask,&old_mask))
     
179.                 printf("block signal SIGRTMIN+10 error\n");
     
180. 
     
181.         sleep(10);       
     
182.         printf("now begin to get pending mask and unblock SIGRTMIN+10\n");
     
183.         if(sigpending(&pending_mask)<0)
     
184.                 printf("get pending mask error\n");
     
185.         if(sigismember(&pending_mask,SIGRTMIN+10))
     
186.                 printf("signal SIGRTMIN+10 is pending\n");
     
187. 
     
188.         if(sigprocmask(SIG_SETMASK,&old_mask,NULL)<0)
     
189.                 printf("unblock signal error\n");
     
190.         printf("signal unblocked\n");
     
191. 
     
192.         sleep(10);
     
193. }
     
194. static void my_op(int signum)
     
195. {
     
196.         printf("receive signal %d \n",signum);
     
197. }
     
198. 
     
199. 
     
200. 编译该程序，并以后台方式运行。在另一终端向该进程发送信号(运行kill -s 42 pid，SIGRTMIN+10为42)，查看结果可以看出几个关键函数的运行机制，信号集相关操作比较简单。
     
201. 
     
202. 注：在上面几个实例中，使用了printf()函数，只是作为诊断工具，pringf()函数是不可重入的，不应在信号处理函数中使用。
     
203. 
     
204. 结束语：
     
205. 
     
206. 系统地对linux信号机制进行分析、总结使我受益匪浅！感谢王小乐等网友的支持！
     
207. Comments and suggestions are greatly welcome!
     
208. 
     
209. 附录1：
     
210. 
     
211. 用sigqueue实现的命令行信号发送程序sigqueuesend，命令行第二个参数是发送的信号值，第三个参数是接收该信号的进程ID，可以配合实例一使用：
     
212. 
     
213. #include <signal.h>
     
214. #include <sys/types.h>
     
215. #include <unistd.h>
     
216. int main(int argc,char**argv)
     
217. {
     
218.         pid_t pid;
     
219.         int sig;
     
220.         sig=atoi(argv[1]);
     
221.         pid=atoi(argv[2]);
     
222.         sigqueue(pid,sig,NULL);
     
223.         sleep(2);
     
224. }
     
225. 
     

复制代码

参考文献：

    * linux内核源代码情景分析（上），毛德操、胡希明著，浙江大学出版社，当要验证某个结论、想法时，最好的参考资料；
    * UNIX环境高级编程，作者：W.Richard Stevens，译者：尤晋元等，机械工业出版社。对信号机制的发展过程阐述的比较详细。
    * signal、sigaction、kill等手册，最直接而可靠的参考资料。
    * http://www.linuxjournal.com/modu ... �的在线指南。
    * http://www.opengroup.org/onlinep ... �的一个网址。
    * http://unix.org/whitepapers/reen ... �进行了阐述。
    * http://www.uccs.edu/~compsvcs/do ... �当好的描述。

home

signal()要在raise()之前。