进程间通信--信号(进程间通信唯一的异步方式)

一、信号的介绍

我们一般都是用第一个，也就是通过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

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. }

运行结果例如以下：

案例二、综合案例

使用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);//璁剧疆瀹氭椂鍣?

    

2.     while(1)
3.     {
4.         n = read(fd,buf,sizeof(buf));
5.         buf[n] = '\0';
6. 
   
7.         printf("Read %d bytes : %s.\n",n,buf);
8. 
   
9.         if(strncmp(buf,"quit",4) == 0 || n == 0)
10.         {
11.             kill(getppid(),SIGKILL);
12.             usleep(500);
13.             exit(EXIT_SUCCESS);
14.         }
15. 
    
16.         alarm(15);
17.     }
18. 
    
19.     return 0;
20. }
21. 
    
22. int father_send_fifo(char *fifo_name,int pid)
23. {
24.     int n,fd;
25.     char buf[MAX];
26. 
    
27.     if((fd = open(fifo_name,O_WRONLY)) < 0)
28.     {
29.         fprintf(stderr,"Fail to open %s : %s.\n",fifo_name,strerror(errno));
30.         return -1;
31.     }
32. 
    
33.     signal(SIGINT,SIG_IGN);
34. 
    
35.     while(1)
36.     {
37.         getchar();
38.         printf(">");
39. 
    
40.         fgets(buf,sizeof(buf),stdin);
41.         buf[strlen(buf)-1] = '\0';
42. 
    
43.         write(fd,buf,strlen(buf));
44. 
    
45.         if(strncmp(buf,"quit",4) == 0)
46.         {
47.             kill(pid,SIGKILL);
48.             usleep(500);
49.             exit(EXIT_SUCCESS);
50.         }
51.     }
52. 
    
53.     return 0;
54. }
55. 
    
56. int main(int argc,char *argv[])
57. {
58.     int pid;
59. 
    
60.     if(argc < 3)
61.     {
62.         fprintf(stderr,"usage %s argv[1].\n",argv[0]);
63.         exit(EXIT_FAILURE);
64.     }
65. 
    
66.     if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
67.     {
68.         perror("Fail to mkfifo");
69.         exit(EXIT_FAILURE);
70.     }
71. 
    
72.     if(mkfifo(argv[2],0666) < 0 && errno != EEXIST)
73.     {
74.         perror("Fail to mkfifo");
75.         exit(EXIT_FAILURE);
76.     }
77.     
78.     if((pid = fork()) < 0)
79.     {
80.     
81.         perror("Fail to fork");
82.         exit(EXIT_FAILURE);
83.     
84.     }else if(pid == 0){
85.         
86.         child_recv_fifo(argv[1]);
87.     
88.     }else{
89. 
    
90.         father_send_fifo(argv[2],pid);
91.     }
92. 
    
93.     exit(EXIT_SUCCESS);
94. }