linux进程间通信--信号

野性酷女 2022-08-06 00:25 212阅读 0赞

一、信号的介绍

信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。

信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了那些系统事件。

如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递个它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞取消时才被传递给进程。

二、linux操作系统支持的信号

A. kill  -l  
  
[![26833883_1338368070RJZ9.png][]][26833883_1338368070RJZ9.png]  
  
B.常用信号的含义  
  
 [![26833883_1338368118pO0w.png][]][26833883_1338368118pO0w.png]  
  
[![26833883_1338368141wW9t.png][]][26833883_1338368141wW9t.png]

三、信号的产生

A.用户在终端按下某些键时，终端驱动程序会发送信号给前台进程，例如ctr+c产生SIGINT,  ctr + \\产生SIGQUI信号，ctr + z产生SIGTSTP。

B.硬件异常产生信号，这些条件由硬件检测到并通知内核，然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令，CPU的运算单元会产生异常，内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址，MMU会产生异常，内核将这个异常解释为SIGSEGV信号发送给当前进程 。

C.一个进程调用int kill(pid\_t pid,int sig)函数可以给另一个进程发送信号

D.可以用kill命令给某个进程发送信号，如果不明确指定信号则发送SIGTERM信号，该信号的默认处理动作是终止进程。

E.当内核检测到某种软件条件发生时也可以通过信号通知进程，例如闹钟超时产生SIGALRM信号，向读端已关闭的管道写数据时产生SIGPIPE信号。

四、进程对信号的处理

A.忽略此信号

B.执行该信号的默认处理动作

C .提供一个信号处理函数，要求内核在处理该信号时切换到用户态执行这个处理函数，这种方式成为捕捉(Catch)一个信号。

五、相关信号API

A.通过系统调用向一个指定的进程发送信号  
  
[![26833883_13383681747UiI.png][]][26833883_13383681747UiI.png]

参数说明:

第一个参数：指定发送信号的接收线程

第二个参数：信号的signum

案例一、

父进程从终端输入signum,然后发给子进程

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <sys/types.h>  
    
3.  \#include <signal.h>  
    
4.  \#include <stdlib.h>  
    
5.    
    
6.  int main()  
    
7.  \{   
    
8.      int pid;  
    
9.    
    
10.     if((pid = fork()) < 0)  
    
11.     \{   
    
12.       
    
13.         perror("Fail to fork");  
    
14.         exit(EXIT\_FAILURE);  
    
15.       
    
16.     \}else if(pid == 0)\{   
    
17.           
    
18.         while(1);  
    
19.       
    
20.     \}else\{   
    
21.           
    
22.         int signum;  
    
23.           
    
24.         while(scanf("%d",&signum) == 1)  
    
25.         \{   
    
26.             kill(pid,signum);  
    
27.             system("ps -aux | grep a.out");  
    
28.         \}  
    
29.     \}  
    
30.   
    
31.     return 0;  
    
32. \}

运行结果如下:  
  
 [![26833883_1338368246TAub.png][]][26833883_1338368246TAub.png]  
  
B.捕捉一个信号  
  
 [![26833883_1338368273dQ8B.png][]][26833883_1338368273dQ8B.png]  
  
对应的API  
  
 [![26833883_13383682995iuI.png][]][26833883_13383682995iuI.png]  
  
其原型:  
  
 [![26833883_1338368334x8n8.png][]][26833883_1338368334x8n8.png]

我们一般都是用第一个，也就是通过typedef改写过的。

注意：signal函数我一般认为其是向内核注册当前进程收到信号的处理的方式。

signal(SIGINT,handler);

参数说明:

signum  :  指定信号

handler  :  SIG\_IGN忽略该信号，SIG\_DFL采用系统默认方式处理信号,自定义的信号处理函数指针。

案例探究:

通过异步方式，给子进程收尸

注意：子进程在终止时会给父进程发SIGCHLD，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需要专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <signal.h>  
    
3.  \#include <unistd.h>  
    
4.  \#include <stdlib.h>  
    
5.    
    
6.  void child\_exit\_handler(int signum)  
    
7.  \{   
    
8.      if(signum == SIGCHLD)  
    
9.      \{   
    
10.         printf("Child exit.\\n");  
    
11.         wait(NULL);  
    
12.     \}  
    
13. \}  
    
14.   
    
15. int main()  
    
16. \{   
    
17.     int pid;  
    
18.     int i = 0;  
    
19.   
    
20.     //想内核注册，处理 SIGCHLD信号的方式  
    
21.     signal(SIGCHLD,child\_exit\_handler);  
    
22.   
    
23.     if((pid = fork()) < 0)  
    
24.     \{   
    
25.         perror("Fail to fork");  
    
26.         exit(EXIT\_FAILURE);  
    
27.   
    
28.     \}else if(pid == 0)\{   
    
29.           
    
30.         for(i = 0;i < 5;i \+\+)  
    
31.         \{   
    
32.             printf("child loop.\\n");  
    
33.             sleep(1);  
    
34.         \}  
    
35.       
    
36.     \}else\{   
    
37.           
    
38.         for(i = 0;i < 5;i \+\+)  
    
39.         \{   
    
40.             printf("Father loop.\\n");  
    
41.             sleep(2);  
    
42.         \}  
    
43.   
    
44.     \}  
    
45.   
    
46.     exit(EXIT\_SUCCESS);  
    
47. \}

C.闹钟函数alarm

[![26833883_1338368388F4VC.png][]][26833883_1338368388F4VC.png]

larm()也称为闹钟函数，它可以在进程中设置一个定时器。当定时器指定的时间到时，内核就向进程发送SIGALARM信号。

seconds:指定的秒数，如果参数seconds为0，则之前设置的闹钟会被取消，并将剩下的时间返回。

成功:如果调用此alarm()前，进程中已经设置了闹钟时间，则放回上一个闹钟时间的剩余时间，否则返回0。

alarm(100);

........

......

alarm(5);

出错:-1

案例探究:

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <signal.h>  
    
3.  \#include <stdlib.h>  
    
4.    
    
5.  void handler(int signum)  
    
6.  \{   
    
7.      if(signum == SIGALRM)  
    
8.      \{   
    
9.          printf("Recv SIGALARM.\\n");  
    
10.     \}  
    
11.   
    
12.     exit(EXIT\_SUCCESS);  
    
13. \}  
    
14.   
    
15. int main()  
    
16. \{   
    
17.     int count = 0;  
    
18.     int n = 0;  
    
19.   
    
20.     signal(SIGALRM,handler);  
    
21.   
    
22.     n = alarm(10);  
    
23.   
    
24.     printf("n = %d.\\n",n);  
    
25.       
    
26.     sleep(2);  
    
27.   
    
28.     n = alarm(5);  
    
29.   
    
30.     printf("n = %d.\\n",n);  
    
31.       
    
32.     while(1)  
    
33.     \{   
    
34.         printf("count = %d.\\n", \+\+count);  
    
35.         sleep(1);  
    
36.     \}  
    
37.   
    
38.     return 0;  
    
39. \}

运行结果如下：

[![26833883_1338368443Z90f.png][]][26833883_1338368443Z90f.png]

案例二、综合案例

使用FIFO实现clientA与clientB之间聊天

A.输入quit后，两个进程退出

B.如果在20秒内，没有等到另一端发来的消息，则认为对方已不在，此时终止。

clientA:

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <stdlib.h>  
    
3.  \#include <signal.h>  
    
4.  \#include <sys/types.h>  
    
5.  \#include <sys/stat.h>  
    
6.  \#include <errno.h>  
    
7.  \#include <string.h>  
    
8.  \#include <fcntl.h>  
    
9.    
    
10. \#define MAX 100  
    
11.   
    
12. void signal\_handler(int signum)  
    
13. \{   
    
14.     static int flag = 0;  
    
15.   
    
16.     switch(signum)  
    
17.     \{   
    
18.         case SIGALRM:  
    
19.             if(flag == 0)  
    
20.             \{   
    
21.                 printf("The people is leaving,the system is closed in 10 seconds \\  
    
22.                         and you can input 'ctrl + c' cancel.\\n");  
    
23.                 alarm(10);  
    
24.             \}else\{   
    
25.                   
    
26.                 kill(getppid(),SIGKILL);  
    
27.                 usleep(500);  
    
28.                 exit(EXIT\_SUCCESS);  
    
29.             \}  
    
30.   
    
31.             flag = 1;              
    
32.             break;  
    
33.   
    
34.         case SIGINT:  
    
35.             printf("The alarm is cancel.\\n");  
    
36.             alarm(0);  
    
37.             break;  
    
38.     \}  
    
39.   
    
40. \}  
    
41.   
    
42. int child\_recv\_fifo(char \*fifo\_name)  
    
43. \{   
    
44.     int n,fd;  
    
45.     char buf\[MAX\];  
    
46.   
    
47.     if((fd = open(fifo\_name,O\_RDONLY)) < 0)  
    
48.     \{   
    
49.         fprintf(stderr,"fail to open %s : %s.\\n",fifo\_name,strerror(errno));  
    
50.         return \-1;  
    
51.     \}  
    
52.   
    
53.     signal(SIGALRM,signal\_handler);  
    
54.     signal(SIGINT,signal\_handler);  
    
55.     alarm(15);//璁剧疆瀹氭椂鍣?      
    
56.     while(1)  
    
57.     \{   
    
58.         n = read(fd,buf,sizeof(buf));  
    
59.         buf\[n\] = '\\0';  
    
60.   
    
61.         printf("Read %d bytes : %s.\\n",n,buf);  
    
62.   
    
63.         if(strncmp(buf,"quit",4) == 0 || n == 0)  
    
64.         \{   
    
65.             kill(getppid(),SIGKILL);  
    
66.             usleep(500);  
    
67.             exit(EXIT\_SUCCESS);  
    
68.         \}  
    
69.   
    
70.         alarm(15);  
    
71.     \}  
    
72.   
    
73.     return 0;  
    
74. \}  
    
75.   
    
76. int father\_send\_fifo(char \*fifo\_name,int pid)  
    
77. \{   
    
78.     int n,fd;  
    
79.     char buf\[MAX\];  
    
80.   
    
81.     if((fd = open(fifo\_name,O\_WRONLY)) < 0)  
    
82.     \{   
    
83.         fprintf(stderr,"Fail to open %s : %s.\\n",fifo\_name,strerror(errno));  
    
84.         return \-1;  
    
85.     \}  
    
86.   
    
87.     signal(SIGINT,SIG\_IGN);  
    
88.   
    
89.     while(1)  
    
90.     \{   
    
91.         getchar();  
    
92.         printf(">");  
    
93.   
    
94.         fgets(buf,sizeof(buf),stdin);  
    
95.         buf\[strlen(buf)\-1\] = '\\0';  
    
96.   
    
97.         write(fd,buf,strlen(buf));  
    
98.   
    
99.         if(strncmp(buf,"quit",4) == 0)  
    
100.         \{   
    
101.             kill(pid,SIGKILL);  
    
102.             usleep(500);  
    
103.             exit(EXIT\_SUCCESS);  
    
104.         \}  
    
105.     \}  
    
106.   
    
107.     return 0;  
    
108. \}  
    
109.   
    
110. int main(int argc,char \*argv\[\])  
    
111. \{   
    
112.     int pid;  
    
113.   
    
114.     if(argc < 3)  
    
115.     \{   
    
116.         fprintf(stderr,"usage %s argv\[1\].\\n",argv\[0\]);  
    
117.         exit(EXIT\_FAILURE);  
    
118.     \}  
    
119.   
    
120.     if(mkfifo(argv\[1\],0666) < 0 && errno != EEXIST)  
    
121.     \{   
    
122.         perror("Fail to mkfifo");  
    
123.         exit(EXIT\_FAILURE);  
    
124.     \}  
    
125.   
    
126.     if(mkfifo(argv\[2\],0666) < 0 && errno != EEXIST)  
    
127.     \{   
    
128.         perror("Fail to mkfifo");  
    
129.         exit(EXIT\_FAILURE);  
    
130.     \}  
    
131.       
    
132.     if((pid = fork()) < 0)  
    
133.     \{   
    
134.       
    
135.         perror("Fail to fork");  
    
136.         exit(EXIT\_FAILURE);  
    
137.       
    
138.     \}else if(pid == 0)\{   
    
139.           
    
140.         child\_recv\_fifo(argv\[2\]);  
    
141.       
    
142.     \}else\{   
    
143.   
    
144.         father\_send\_fifo(argv\[1\],pid);  
    
145.     \}  
    
146.   
    
147.     exit(EXIT\_SUCCESS);  
    
148. \}

client B

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <stdlib.h>  
    
3.  \#include <signal.h>  
    
4.  \#include <sys/types.h>  
    
5.  \#include <sys/stat.h>  
    
6.  \#include <errno.h>  
    
7.  \#include <string.h>  
    
8.  \#include <fcntl.h>  
    
9.    
    
10. \#define MAX 100  
    
11.   
    
12. void signal\_handler(int signum)  
    
13. \{   
    
14.     static int flag = 0;  
    
15.   
    
16.     switch(signum)  
    
17.     \{   
    
18.         case SIGALRM:  
    
19.             if(flag == 0)  
    
20.             \{   
    
21.                 printf("The people is leaving,the system is closed in 10 seconds \\  
    
22.                         and you can input 'ctrl + c' cancel.\\n");  
    
23.                 alarm(10);  
    
24.             \}else\{   
    
25.                   
    
26.                 kill(getppid(),SIGKILL);  
    
27.                 usleep(500);  
    
28.                 exit(EXIT\_SUCCESS);  
    
29.             \}  
    
30.   
    
31.             flag = 1;              
    
32.             break;  
    
33.   
    
34.         case SIGINT:  
    
35.             printf("The alarm is cancel.\\n");  
    
36.             alarm(0);  
    
37.             break;  
    
38.     \}  
    
39.   
    
40. \}  
    
41.   
    
42. int child\_recv\_fifo(char \*fifo\_name)  
    
43. \{   
    
44.     int n,fd;  
    
45.     char buf\[MAX\];  
    
46.   
    
47.     if((fd = open(fifo\_name,O\_RDONLY)) < 0)  
    
48.     \{   
    
49.         fprintf(stderr,"fail to open %s : %s.\\n",fifo\_name,strerror(errno));  
    
50.         return \-1;  
    
51.     \}  
    
52.   
    
53.     signal(SIGALRM,signal\_handler);  
    
54.     signal(SIGINT,signal\_handler);  
    
55.     alarm(15);//璁剧疆瀹氭椂鍣?      
    
56.     while(1)  
    
57.     \{   
    
58.         n = read(fd,buf,sizeof(buf));  
    
59.         buf\[n\] = '\\0';  
    
60.   
    
61.         printf("Read %d bytes : %s.\\n",n,buf);  
    
62.   
    
63.         if(strncmp(buf,"quit",4) == 0 || n == 0)  
    
64.         \{   
    
65.             kill(getppid(),SIGKILL);  
    
66.             usleep(500);  
    
67.             exit(EXIT\_SUCCESS);  
    
68.         \}  
    
69.   
    
70.         alarm(15);  
    
71.     \}  
    
72.   
    
73.     return 0;  
    
74. \}  
    
75.   
    
76. int father\_send\_fifo(char \*fifo\_name,int pid)  
    
77. \{   
    
78.     int n,fd;  
    
79.     char buf\[MAX\];  
    
80.   
    
81.     if((fd = open(fifo\_name,O\_WRONLY)) < 0)  
    
82.     \{   
    
83.         fprintf(stderr,"Fail to open %s : %s.\\n",fifo\_name,strerror(errno));  
    
84.         return \-1;  
    
85.     \}  
    
86.   
    
87.     signal(SIGINT,SIG\_IGN);  
    
88.   
    
89.     while(1)  
    
90.     \{   
    
91.         getchar();  
    
92.         printf(">");  
    
93.   
    
94.         fgets(buf,sizeof(buf),stdin);  
    
95.         buf\[strlen(buf)\-1\] = '\\0';  
    
96.   
    
97.         write(fd,buf,strlen(buf));  
    
98.   
    
99.         if(strncmp(buf,"quit",4) == 0)  
    
100.         \{   
    
101.             kill(pid,SIGKILL);  
    
102.             usleep(500);  
    
103.             exit(EXIT\_SUCCESS);  
    
104.         \}  
    
105.     \}  
    
106.   
    
107.     return 0;  
    
108. \}  
    
109.   
    
110. int main(int argc,char \*argv\[\])  
    
111. \{   
    
112.     int pid;  
    
113.   
    
114.     if(argc < 3)  
    
115.     \{   
    
116.         fprintf(stderr,"usage %s argv\[1\].\\n",argv\[0\]);  
    
117.         exit(EXIT\_FAILURE);  
    
118.     \}  
    
119.   
    
120.     if(mkfifo(argv\[1\],0666) < 0 && errno != EEXIST)  
    
121.     \{   
    
122.         perror("Fail to mkfifo");  
    
123.         exit(EXIT\_FAILURE);  
    
124.     \}  
    
125.   
    
126.     if(mkfifo(argv\[2\],0666) < 0 && errno != EEXIST)  
    
127.     \{   
    
128.         perror("Fail to mkfifo");  
    
129.         exit(EXIT\_FAILURE);  
    
130.     \}  
    
131.       
    
132.     if((pid = fork()) < 0)  
    
133.     \{   
    
134.       
    
135.         perror("Fail to fork");  
    
136.         exit(EXIT\_FAILURE);  
    
137.       
    
138.     \}else if(pid == 0)\{   
    
139.           
    
140.         child\_recv\_fifo(argv\[1\]);  
    
141.       
    
142.     \}else\{   
    
143.   
    
144.         father\_send\_fifo(argv\[2\],pid);  
    
145.     \}  
    
146.   
    
147.     exit(EXIT\_SUCCESS);  
    
148. \}

D.将进程挂起函数pause  
  
 [![26833883_1338368523ssSV.png][]][26833883_1338368523ssSV.png]

解释如下:

[![26833883_1338368548ee3E.png][]][26833883_1338368548ee3E.png]  
  
案例如下:  
  
 [![26833883_13383685789XzG.png][]][26833883_13383685789XzG.png]

[26833883_1338368070RJZ9.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368070RJZ9.png
[26833883_1338368118pO0w.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368118pO0w.png
[26833883_1338368141wW9t.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368141wW9t.png
[26833883_13383681747UiI.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_13383681747UiI.png
[26833883_1338368246TAub.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368246TAub.png
[26833883_1338368273dQ8B.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368273dQ8B.png
[26833883_13383682995iuI.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_13383682995iuI.png
[26833883_1338368334x8n8.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368334x8n8.png
[26833883_1338368388F4VC.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368388F4VC.png
[26833883_1338368443Z90f.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368443Z90f.png
[26833883_1338368523ssSV.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368523ssSV.png
[26833883_1338368548ee3E.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_1338368548ee3E.png
[26833883_13383685789XzG.png]: http://blog.chinaunix.net/attachment/201205/30/26833883_13383685789XzG.png