信号.txt

LINUX进程通信的学习资料

12. 	pid_t pid;		
13. 	char data[10];
14. 	memset(data,0,sizeof(data));
15. 	for(i=0;i < 5;i++)
16. 		data[i]='2';
17. 	mysigval.sival_ptr=data;
18. 	
19. 	sig=atoi(argv[1]);
20. 	pid=getpid();
21. 	
22. 	sigemptyset(&act.sa_mask);
23. 	act.sa_sigaction=new_op;//三参数信号处理函数
24. 	act.sa_flags=SA_SIGINFO;//信息传递开关
25. 	if(sigaction(sig,&act,NULL) < 0)
26. 	{
27. 		printf("install sigal error\n");
28. 	}
29. 	while(1)
30. 	{
31. 		sleep(2);
32. 		printf("wait for the signal\n");
33. 		sigqueue(pid,sig,mysigval);//向本进程发送信号，并传递附加信息
34. 	}
35. 
36. }
37. 
38. void new_op(int signum,siginfo_t *info,void *myact)//三参数信号处理函数的实现
39. {
40. 	int i;
41. 	for(i=0;i<10;i++)
42. 	{
43. 		printf("%c\n ",(*( (char*)((*info).si_ptr)+i)));
44. 	}
45. 	printf("handle signal %d over;",signum);
46. }
47. 
这个例子中，信号实现了附加信息的传递，信号究竟如何对这些信息进行处理则取决于具体的应用。
48. 2、 不同进程间传递整型参数：把1中的信号发送和接收放在两个程序中，并且在发送过程中传递整型参数。
信号接收程序： 
49. #include <signal.h>
50. #include <sys/types.h>
51. #include <unistd.h>
52. void new_op(int,siginfo_t*,void*);
53. int main(int argc,char**argv)
54. {
55. 	struct sigaction act;
56. 	int sig;
57. 	pid_t pid;		
58. 	
59. 	pid=getpid();
60. 	sig=atoi(argv[1]);	
61. 	
62. 	sigemptyset(&act.sa_mask);
63. 	act.sa_sigaction=new_op;
64. 	act.sa_flags=SA_SIGINFO;
65. 	if(sigaction(sig,&act,NULL)<0)
66. 	{
67. 		printf("install sigal error\n");
68. 	}
69. 	while(1)
70. 	{
71. 		sleep(2);
72. 		printf("wait for the signal\n");
73. 	}
74. 
75. }
76. void new_op(int signum,siginfo_t *info,void *myact)
77. {
78. 	printf("the int value is %d \n",info->si_int);
79. }
80. 
信号发送程序：命令行第二个参数为信号值，第三个参数为接收进程ID。
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/types.h>
main(int argc,char**argv)
{
	pid_t pid;
	int signum;
	union sigval mysigval;

	signum=atoi(argv[1]);
	pid=(pid_t)atoi(argv[2]);
	mysigval.sival_int=8;//不代表具体含义，只用于说明问题

	if(sigqueue(pid,signum,mysigval)==-1)
		printf("send error\n");
	sleep(2);
}

注：实例2的两个例子侧重点在于用信号来传递信息，目前关于在linux下通过信号传递信息的实例非常少，倒是Unix下有一些，但传递的基本上都是关于传递一个整数，传递指针的我还没看到。我一直没有实现不同进程间的指针传递（实际上更有意义），也许在实现方法上存在问题吧，请实现者email我。
实例三：信号阻塞及信号集操作
#include "signal.h"
#include "unistd.h"
static void my_op(int);
main()
{
	sigset_t new_mask,old_mask,pending_mask;
	struct sigaction act;

	sigemptyset(&act.sa_mask);
	act.sa_flags=SA_SIGINFO;
	act.sa_sigaction=(void*)my_op;
	if(sigaction(SIGRTMIN+10,&act,NULL))
		printf("install signal SIGRTMIN+10 error\n");

	sigemptyset(&new_mask);
	sigaddset(&new_mask,SIGRTMIN+10);
	if(sigprocmask(SIG_BLOCK, &new_mask,&old_mask))
		printf("block signal SIGRTMIN+10 error\n");

	sleep(10);	
	printf("now begin to get pending mask and unblock SIGRTMIN+10\n");
	if(sigpending(&pending_mask)<0)
		printf("get pending mask error\n");
	if(sigismember(&pending_mask,SIGRTMIN+10))
		printf("signal SIGRTMIN+10 is pending\n");

	if(sigprocmask(SIG_SETMASK,&old_mask,NULL)<0)
		printf("unblock signal error\n");
	printf("signal unblocked\n");

	sleep(10);
}
static void my_op(int signum)
{
	printf("receive signal %d \n",signum);
}

编译该程序，并以后台方式运行。在另一终端向该进程发送信号(运行kill -s 42 pid，SIGRTMIN+10为42)，查看结果可以看出几个关键函数的运行机制，信号集相关操作比较简单。
注：在上面几个实例中，使用了printf()函数，只是作为诊断工具，pringf()函数是不可重入的，不应在信号处理函数中使用。
结束语：
系统地对linux信号机制进行分析、总结使我受益匪浅！感谢王小乐等网友的支持！
Comments and suggestions are greatly welcome! 
附录1：
用sigqueue实现的命令行信号发送程序sigqueuesend，命令行第二个参数是发送的信号值，第三个参数是接收该信号的进程ID，可以配合实例一使用：
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc,char**argv)
{
	pid_t pid;
	int sig;
	sig=atoi(argv[1]);
	pid=atoi(argv[2]);
	sigqueue(pid,sig,NULL);
	sleep(2);
}