zoukankan      html  css  js  c++  java

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

    一、信号的介绍

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


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

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

    二、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. ");
    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. ");
    33.             sleep(1);
    34.         }
    35.     
    36.     }else{
    37.         
    38.         for(i = 0;i < 5;i ++)
    39.         {
    40.             printf("Father loop. ");
    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. ");
    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);
    25.     
    26.     sleep(2);

    28.     n = alarm(5);

    30.     printf("n = %d. ",n);
    31.     
    32.     while(1)
    33.     {
    34.         printf("count = %d. ", ++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. ");
    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. ");
    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. ",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,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. ",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]. ",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. ");
    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. ");
    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. ",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,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. ",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]. ",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



    解释例如以下:



    案比例如以下:



    <script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"2","bdMiniList":false,"bdPic":"","bdStyle":"0","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script>
    阅读(31) | 评论(0) | 转发(0) |
    0

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

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

    相关热门文章
给主人留下些什么吧！~~
评论热议
查看全文
  • 相关阅读:
    install sklearn-crfsuite on mac
    排序算法之选择排序
    排序算法之冒泡排序
    Python中__init__与self的解释
    Python中 if __name__ == "__main__"解释
    Python活力练习Day25
    Python活力练习Day24
    Python活力练习Day23
    动态规划之编辑距离
    Python活力练习Day22
  • 原文地址：https://www.cnblogs.com/claireyuancy/p/7365765.html
    • Copyright © 2011-2022 走看看