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

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

原文地址：进程间通信--信号(进程间通信唯一的异步方式) 作者：Deem_passion

一、信号的介绍

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

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

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

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

A. kill  -l



B.常用信号的含义

三、信号的产生

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.通过系统调用向一个指定的进程发送信号

参数说明:

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

第二个参数：信号的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. }

运行结果如下:



B.捕捉一个信号



对应的API



其原型:

我们一般都是用第一个，也就是通过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);//璁剧疆瀹氭椂鍣?    
    

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

解释如下:

案例如下: