测测你的Linux如何处理信号量？


在你的Linux系统中，一个进程是如何响应多个信号的？

做个小实验～上代码。

  1.    
  2. #include<stdio.h>   
  3. #include<signal.h>   
  4.   
  5. #define INPUTLEN  (100)   
  6.   
  7. int main(int ac, char* av[])  
  8. {  
  9.     void inthandler(int);  
  10.     void quithandler(int);  
  11.     char input[INPUTLEN];  
  12.     int  nchars;  
  13.       
  14.     signal(SIGINT, inthandler);  
  15.     signal(SIGQUIT, quithandler);  
  16.   
  17.     do{  
  18.         printf("\nType a message\n");   
  19.         nchars = read(0, input, (INPUTLEN-1));  
  20.         if(nchars == -1)  
  21.             perror("read returned an error");  
  22.         else  
  23.         {  
  24.             input[nchars] = '\0';  
  25.             printf("You typed: %s", input);  
  26.         }  
  27.     }while(strncmp(input, "quit", 4) != 0);  
  28. }  
  29.   
  30. void inthandler(int s)  
  31. {  
  32.     printf("Received signal %d.. waiting\n", s);  
  33.     sleep(2);  
  34.     printf("Leaving inthandler\n");  
  35. }  
  36.   
  37. void quithandler(int s)  
  38. {  
  39.     printf("Received signal %d .. waiting \n", s);  
  40.     sleep(3);  
  41.     printf("Leaving quithandler\n");  
  42. }  

     流程很简单，为SIGINT，SIGQUIT设定信号处理函数，主程序一直循环，接收来自stdin的输入，直到接收到"quit"结束。

     SIGINT 信号，可以由ctrl＋c 来产生，SIGQUIT信号，可以由 ctrl+\ 来产生。编译之后，来看现象。

1、SIGINT＋SIGINT＋SIGINT＋SIGINT（多个相同信号）

    笔者的系统是Ubuntu9.10，连续发送4个SIGINT后，系统先处理一个，再阻塞一个，忽略后两个。处理完第一个后，阻塞的才被处理。SIGQUIT同样效果。

    如果两个SIGINT就杀死了进程，那么意味着你的系统是不可靠的信号: 处理函数必须每次都重置。如果多个SIGINT信号没有杀死进程，意味着处理函数在被调用后还起到作用。后者对重复信号的处理，一般有三个选择：

    （1）.递归，调用同一个处理函数。（非显式递归，虽然处理函数没有调用自己，但是效果相同，如果设置一个静态变量在这里，效果就更明显了～～）

    （2）.忽略第二个。

    （3）.阻塞第二个信号直到第一个处理完毕。

     当然了，你的Linux很可能会将多个信号进行入队操作，一个接一个处理完毕，或者有限地抛弃。

2、SIGINT＋SIGQUIT＋SIGINT＋SIGQUIT（不同信号交替）

    这里同样处理一个，阻塞一个，忽略后两个。当先后发送SIGINT 和SIGQUIT后，会看到程序先跳到inthandler, 接着跳到quithandler。然后再回到inthandler，最后回到主循环。

3、在处理信号的时候，输入字符。

    很幸运，在信号处理完毕返回主程序的时候，所于的输入都正确处理并返回了。

从这个小实验中，我们会发现使用signal（），来设定信号量的处理方式过于被动，而且简陋。首先，我们无法获知中断信号的来源。这样导致我们设定信号处理函数的时候能预防的情况过少。其次，多个信号的处理方式无法亲手设定，阻塞还是抛弃？如果要处理，阻塞多少个？还有，在信号处理返回的时候，已经执行的函数，或者系统调用，是重新开始，还是继续进行？对于一些不可重入函数，这一点就非常关键。能自由定制信号量，很有必要的。

相关内容