码迷，mamicode.com
首页 > 系统相关 > 详细

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

时间：2016-04-01 18:25:57      阅读：289      评论：0      收藏：0      [点我收藏+]

标签：

一、信号的介绍

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

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

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

二、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>

  6. int main()
  7. {
  8.     int pid;

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

  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>

  6. void child_exit_handler(int signum)
  7. {
  8.     if(signum == SIGCHLD)
  9.     {
  10.         printf("Child exit.\n");
  11.         wait(NULL);
  12.     }
  13. }

  15. int main()
  16. {
  17.     int pid;
  18.     int i = 0;

  20.     //想内核注册，处理 SIGCHLD信号的方式
  21.     signal(SIGCHLD,child_exit_handler);

  23.     if((pid = fork()) < 0)
  24.     {
  25.         perror("Fail to fork");
  26.         exit(EXIT_FAILURE);

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

  44.     }

  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>

  5. void handler(int signum)
  6. {
  7.     if(signum == SIGALRM)
  8.     {
  9.         printf("Recv SIGALARM.\n");
  10.     }

  12.     exit(EXIT_SUCCESS);
  13. }

  15. int main()
  16. {
  17.     int count = 0;
  18.     int n = 0;

  20.     signal(SIGALRM,handler);

  22.     n = alarm(10);

  24.     printf("n = %d.\n",n);
  25.     
  26.     sleep(2);

  28.     n = alarm(5);

  30.     printf("n = %d.\n",n);
  31.     
  32.     while(1)
  33.     {
  34.         printf("count = %d.\n", ++count);
  35.         sleep(1);
  36.     }

  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>

  10. #define MAX 100

  12. void signal_handler(int signum)
  13. {
  14.     static int flag = 0;

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

  31.             flag = 1;            
  32.             break;

  34.         case SIGINT:
  35.             printf("The alarm is cancel.\n");
  36.             alarm(0);
  37.             break;
  38.     }

  40. }

  42. int child_recv_fifo(char *fifo_name)
  43. {
  44.     int n,fd;
  45.     char buf[MAX];

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

  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‘;

  61.         printf("Read %d bytes : %s.\n",n,buf);

  63.         if(strncmp(buf,"quit",4) == 0 || n == 0)
  64.         {
  65.             kill(getppid(),SIGKILL);
  66.             usleep(500);
  67.             exit(EXIT_SUCCESS);
  68.         }

  70.         alarm(15);
  71.     }

  73.     return 0;
  74. }

  76. int father_send_fifo(char *fifo_name,int pid)
  77. {
  78.     int n,fd;
  79.     char buf[MAX];

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

  87.     signal(SIGINT,SIG_IGN);

  89.     while(1)
  90.     {
  91.         getchar();
  92.         printf(">");

  94.         fgets(buf,sizeof(buf),stdin);
  95.         buf[strlen(buf)-1] = ‘\0‘;

  97.         write(fd,buf,strlen(buf));

  99.         if(strncmp(buf,"quit",4) == 0)
  100.         {
  101.             kill(pid,SIGKILL);
  102.             usleep(500);
  103.             exit(EXIT_SUCCESS);
  104.         }
  105.     }

  107.     return 0;
  108. }

  110. int main(int argc,char *argv[])
  111. {
  112.     int pid;

  114.     if(argc < 3)
  115.     {
  116.         fprintf(stderr,"usage %s argv[1].\n",argv[0]);
  117.         exit(EXIT_FAILURE);
  118.     }

  120.     if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
  121.     {
  122.         perror("Fail to mkfifo");
  123.         exit(EXIT_FAILURE);
  124.     }

  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{

  144.         father_send_fifo(argv[1],pid);
  145.     }

  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>

  10. #define MAX 100

  12. void signal_handler(int signum)
  13. {
  14.     static int flag = 0;

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

  31.             flag = 1;            
  32.             break;

  34.         case SIGINT:
  35.             printf("The alarm is cancel.\n");
  36.             alarm(0);
  37.             break;
  38.     }

  40. }

  42. int child_recv_fifo(char *fifo_name)
  43. {
  44.     int n,fd;
  45.     char buf[MAX];

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

  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‘;

  61.         printf("Read %d bytes : %s.\n",n,buf);

  63.         if(strncmp(buf,"quit",4) == 0 || n == 0)
  64.         {
  65.             kill(getppid(),SIGKILL);
  66.             usleep(500);
  67.             exit(EXIT_SUCCESS);
  68.         }

  70.         alarm(15);
  71.     }

  73.     return 0;
  74. }

  76. int father_send_fifo(char *fifo_name,int pid)
  77. {
  78.     int n,fd;
  79.     char buf[MAX];

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

  87.     signal(SIGINT,SIG_IGN);

  89.     while(1)
  90.     {
  91.         getchar();
  92.         printf(">");

  94.         fgets(buf,sizeof(buf),stdin);
  95.         buf[strlen(buf)-1] = ‘\0‘;

  97.         write(fd,buf,strlen(buf));

  99.         if(strncmp(buf,"quit",4) == 0)
  100.         {
  101.             kill(pid,SIGKILL);
  102.             usleep(500);
  103.             exit(EXIT_SUCCESS);
  104.         }
  105.     }

  107.     return 0;
  108. }

  110. int main(int argc,char *argv[])
  111. {
  112.     int pid;

  114.     if(argc < 3)
  115.     {
  116.         fprintf(stderr,"usage %s argv[1].\n",argv[0]);
  117.         exit(EXIT_FAILURE);
  118.     }

  120.     if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
  121.     {
  122.         perror("Fail to mkfifo");
  123.         exit(EXIT_FAILURE);
  124.     }

  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{

  144.         father_send_fifo(argv[2],pid);
  145.     }

  147.     exit(EXIT_SUCCESS);
  148. }

D.将进程挂起函数pause

技术分享

解释如下:

技术分享

案例如下:

技术分享

阅读(31) | 评论(0) | 转发(0) |
0

上一篇：进程间通信---共享内存

下一篇：linux 进程(二) --- 进程的创建及相关api

相关热门文章
给主人留下些什么吧！~~
评论热议

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

标签：

原文地址：http://blog.csdn.net/u011311586/article/details/51037230

踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！