可靠信号

转自　　http://blog.csdn.net/todd911/article/details/17121241

在产生信号时，内核通常在进程表中设置某一种形式的标志。当对信号采取了这种动作时，我们说向进程递送了一个信号。在信号产生和递送之间的时间间隔内，称信号是未决的。进程可以选用信号递送阻塞。如果为进程产生了一个选择为阻塞的信号，而且对该进程的动作是默认动作或捕捉该信号，则为该进程将此信号保持为未决状态，直到该进程

（1）对此信号解除了阻塞，或者（2）将此信号的动作更改为忽略。

内核在递送一个原来被阻塞的信号给进程时（而不是在产生该信号时），才决定对它的处理方式。于是子进程在信号递送给他之前仍可改变对该信号的动作。

信号在内核中的表示可以看作是这样的：

 

每个信号都有两个标志位分别表示阻塞和未决，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。在上图的例子中，

1. SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。

2. SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞。
3. SIGQUIT信号未产生过，一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。

如果在进程解除对某个信号的阻塞之前，这种信号发生了多次，那么将如何呢？POSIX.1允许系统递送该信号一次或多次，

如果递送多次，则称对这些信号进行排队。Linux是这样实现的：常规信号在递达之前产生多次只计一次，而实时信号在递达之前

产生多次可以依次放在一个队列里。

实践：

#include <stdio.h>  
#include <signal.h>  
#include <unistd.h>    
static void sighandle(int signo){  
        printf("receive %d\n",signo);  
}    
int main(void){  
        sigset_t newmask,oldmask;  
        sigemptyset(&newmask);  
        sigaddset(&newmask,SIGUSR1);  
        if(sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0){  
                perror("sigprocmask");  
                return -1;  
        }    
        signal(SIGUSR1, sighandle);  
        sleep(20);  
        if(sigprocmask(SIG_UNBLOCK, &newmask, &oldmask) < 0){  
                perror("sigprocmask");  
                return -1;  
        }  
        while(1){  
                pause();  
        }  
        return 0;  
}    

运行结果： 

$ ./a.out &
[1] 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ kill -SIGUSR1 7776
$ receive 10

一开始sigusr1信号被屏蔽，在sleep的时候，发送多个sigusr1给进程，等进程苏醒后，解除sigusr1的信号屏蔽，此时信号处理函数只执行了1次，也就是之前发送的信号只计一次。 

如果在信号处理函数执行过程中，又有信号产生，会怎样？

使用如下程序进行验证： 

#include <stdio.h>  
#include <signal.h>    
static void sighandle(int signo){  
        printf("sig %d start\n",signo);  
        sleep(10);  
        printf("sig %d end\n",signo);  
}  
  
int main(void){  
        if(signal(SIGUSR1,sighandle)){  
                perror("signal");  
                return -1;  
        }  
        if(signal(SIGUSR2,sighandle)){  
                perror("signal");  
                return -1;  
        }  
        while(1){  
                pause();  
        }  
        return 0;  
}   

1.如果产生的是相同的信号：

$ ./a.out &
[1] 10037
$ kill -SIGUSR1 10037
$ sig 10 start
kill -SIGUSR1 10037
$ kill -SIGUSR1 10037
$ kill -SIGUSR1 10037
$ sig 10 end
sig 10 start
sig 10 end

只有执行完当前的处理函数后才继续执行下一个相同信号的处理函数，因为在执行信号处理函数时，会将该信号屏蔽，在执行完处理函数后，再解除信号的屏蔽。 

2.如果产生的不是相同的信号：

$ ./a.out &
[1] 10140

kill -SIGUSR1 10140    
$ sig 10 start
kill -SIGUSR2 10140      //等了7，8秒再执行该语句
sig 12 start
$ sig 12 end  //在kill -SIGUSR2 10140执行了10s后出现
sig 10 end   //在sig 12 end出现后立即打印出来

这边的现象就比较奇怪了，如果产生的不是相同的信号，能立即执行新信号的处理函数，但是原来被打断的信号处理函数一直都没有结束，等到新的信号处理函数结束后，旧信号的处理函数才结束。而且是紧更着新的信号处理函数就打印的。不明白是什么原因了，等以后再深入地学习后再来搞个明白吧，或者有哪位高人知道的，请告之，谢谢。