Unix/Linux编程：信号“未决”和“阻塞”&信号集

谁借莪１个温暖的怀抱￠ 2023-01-04 13:25 111阅读 0赞

>  *  很多信号相关的系统调用都需要能表示一组不同的信号。**多个信号可以使用一个称为信号集的数据结构来表示**，其系统数据类型为`sigset_t`。SUSv3规定了一系列函数来操纵信号集。
> 
>  *  像在大多数 UNIX 实现中一样，sigset\_t 数据类型在 Linux 中是一个位掩码。然而，SUSv3对此并无要求。使用其他一些类型的结构来表示信号集也是有可能的。SUSv3 仅要求可对sigset\_t 类型赋值即可。因此，必须使用某些标量类型（比如一个整数）或者一个 C 语言结构（也许包含了一个整型数组）来实现该类型

# 信号“未决”和“阻塞” #

实际执行信号的处理动作称为**信号递达**（Delivery）

*  信号从产生到递达之间的状态，称为信号未决（Pending）。
 *  进程可以选择阻塞（Block）某个信号，SIGKILL 和 SIGSTOP 不能被阻塞
 *  **被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作**

注意，阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作。信号在内核中的表示可以看作是这样的：

*  每个信号都有两个标志位分别表示阻塞和未决，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志
 *  **信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]
 *  信号屏蔽状态字（block），1代表阻塞、0代表不阻塞；
 *  信号未决状态字（pending）的1代表未决，0代表信号可以抵达了；
 *  它们都是每一个bit代表一个信号，比如，bit0代表信号SIGHUP;

**操作系统在信号被进程解除阻塞之前不会讲信号传递出去，被阻塞的信号也不会影响进程的行为，信号只是暂时被阻止传递。当进程忽略一个信号时，信号会被传递出去但进程会将信号丢弃。**

**进程可以选择阻塞（Block）某个信号。被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。注意，阻塞和忽略是不同，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作。**

当进程产生了一个阻塞信号（进程可以选择阻塞（Block）某个信号），而且对该信号动作是系统默认或捕捉该信号，则该信号保持为未决状态，直到以下两种情况的一种发生：

*  1）进程对此信号解除了阻塞；
 *  2）对此信号的动作改为忽略。

比如向进程发送SIGINT，内核首先判断信号屏蔽状态字是否阻塞，如果该信号被设为为了阻塞的，那么信号未决状态字（pending）相应位制成1；若该信号阻塞解除，信号未决状态字（pending）相应位制成0；表示信号此时可以抵达了，也就是可以接收该信号了。

**未决和阻塞标志可以用相同的数据类型sigset\_t来存储，sigset\_t称为信号集**，这个类型可以表示每个信号的“有效”或“无效”状态，

*  在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞
 *  在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

阻塞信号集也叫做当前进程的**信号屏蔽字**（Signal Mask），这里的“屏蔽”应该理解为阻塞而不是忽略。

**每个进程都有一个信号屏蔽字，它规定了当前要阻塞递送到该进程的信号集**

# 信号集 #

sigset\_t类型(64bit)对于每种信号用一个bit表示“有效”或“无效”状态，至于这个类型内部如何存储这些bit则依赖于系统实现，从使用者的角度是不必关心的，使用者只能调用以下函数来操作sigset\_t变量，而不应该对它的内部数据做任何解释，比如用printf直接打印sigset\_t变量是没有意义的。

## 信号集处理函数 ##

*  sigemptyset()：初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号
 *  sigfillset()：初始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号

SYNOPSIS
           #include <signal.h>
    
           int sigemptyset(sigset_t *set);
    
           int sigfillset(sigset_t *set);
    
    RETURN VALUE
           成功时返回0，失败返回-1
    
    Note
    		必须使用 sigemptyset()或者 sigfillset()来初始化信号集。这是因为C语言不会对
    		自动变量进程初始化，并且，借助于将静态变量初始化为0的机制表示空信号集的作法在可
    		移植性上存在问题，因为有可能使用位掩码之外的结构来实现信号集。（出于同一原因，为
    		将信号集标记为空而使用 memset(3)函数将其内容清零的做法也不正确。）

注意，在使用sigset\_t类型的变量之前，一定要调用sigemptyset或sigfillset做初始化，使信号集处于确定的状态。

*  信号集初始化后，可以分别借助sigaddset和sigdelset函数向一个集合中添加或者移除单个信号

SYNOPSIS
           #include <signal.h>
    
           int sigaddset(sigset_t *set, int signum);
    
           int sigdelset(sigset_t *set, int signum);
    
    RETURN VALUE
           成功时返回0，失败返回-1

*  sigismember()函数用来测试信号 sig 是否是信号集 set 的成员

SYNOPSIS
           #include <signal.h>
           
           int sigismember(const sigset_t *set, int signum);
    
    RETURN VALUE
    		如果 sig 是 set 的一个成员，那么 sigismember()函数将返回 1（true），否则返回 0（false）

GNU C 库还实现了 3 个非标准函数，是对上述信号集标准函数的补充

如果定义了_GNU_SOURCE功能测试宏，则<signal.h>将公开其他三个用于处理信号集的函数。 
    
           int sigisemptyset(sigset_t *set);
                 如果set不包含任何信号，则返回1，否则返回0。 
                 
           int sigorset(sigset_t *dest, sigset_t *left, sigset_t *right);
                  sigorset()将 left 集和 right 集的并集置于 dest 集。
    
           int sigandset(sigset_t *dest, sigset_t *left, sigset_t *right);
                 sigandset()将 left 集和 right 集的交集置于 dest 集。
    
           sigorset() and sigandset() 成功返回0，失败则返回-1。 
    
           这些功能是非标准的（其他一些系统提供了类似的功能），应避免使用它们

## 信号掩码（阻塞信号传递） ##

**内核会为每个进程维护一个信号掩码，即一组信号，并将阻塞其针对该进程的传递。如果果将遭阻塞的信号发送给某进程，那么对该信号的传递将延后，直至从进程信号掩码中移除该信号，从而解除阻塞为止**

信号掩码实际属于线程属性，在多线程进程中，每个线程都可使用 pthread\_sigmask()函数来独立检查和修改其信号掩码

向信号掩码中添加一个信号，有如下几种方式：

*  当调用信号处理程序时，可以将引发调用的信号自动添加进信号掩码中。是否发生这一情况，要视 sigaction()函数在安装信号处理器程序时所使用的标志而定。
 *  使用 sigaction()函数建立信号处理器程序时，可以指定一组额外信号，当调用该处理器程序时会将其阻塞。
 *  使用 sigprocmask()系统调用，随时可以显式向信号掩码中添加或移除信号

### sigprocmask ###

SYNOPSIS
           #include <signal.h>
    
           int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
    
    RETURN VALUE
    		成功执行时，返回0。失败返回-1，errno被设为EINVAL

使用 sigprocmask可以**设定对信号屏蔽集内的信号的处理方式(阻塞或不阻塞)**，又可获取现有掩码，或者两重功效兼具。

*  oldset：若 oldset 参数不为空，用于返回之前的信号掩码； 如果为NULL，表示对之前的信号不敢兴趣
 *  set：若 set参数不为空，可以更改进程的信号屏蔽字； 如果为NULL，读取现在的屏蔽值
 *  how：用于指定信号修改的方式，可能选择有三种

<table> 
 <thead> 
  <tr> 
   <th>how</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>SIG_BLOCK</code></td> 
   <td>将参数set指向的信号集中设置的信号添加到现在的屏蔽状态字中，设置为阻塞；</td> 
  </tr> 
  <tr> 
   <td><code>SIG_UNBLOCK</code></td> 
   <td>将参数set指向的信号集中设置的信号添加到现在的屏蔽状态字中，设置为非阻塞， 也就是解除阻塞；</td> 
  </tr> 
  <tr> 
   <td><code>SIG_SETMASK</code></td> 
   <td>将 set 指向的信号集赋给信号掩码。</td> 
  </tr> 
 </tbody> 
</table>

如果想暂时阻塞信号的传递：先阻塞信号，然后再将信号掩码重置为先前的状态以解除对信号的绑定：

sigset_t blockSet, prevMask;
        
        // 初始化一个包含SITGINT的信号集
        sigemptyset(&blockSet);
        sigaddset(&blockSet, SIGINT);
        
        // 阻塞信号，保存先前的掩码
        if (sigprocmask(SIG_BLOCK, &blockSet, &prevMask) == -1){
        
            perror("sigprocmask");
            exit(EXIT_FAILURE);
        }
        
        
        // 这里的代码不会被 SIGINT信号打断
        
        //重置为先前的掩码以解除对信号的绑定
        if (sigprocmask(SIG_SETMASK, &prevMask, NULL) == -1){
        
            perror("sigprocmask");
            exit(EXIT_FAILURE);
        }

SUSv3 规定，如果有任何等待信号因对 sigprocmask()的调用而解除了锁定，那么在此调用返回前至少会传递一个信号。换言之，如果解除了对某个等待信号的锁定，那么会立刻将该信号传递给进程

系统将忽略试图阻塞 SIGKILL 和 SIGSTOP 信号的请求。如果试图阻塞这些信号，sigprocmask()函数既不会予以关注，也不会产生错误。这意味着，可以使用如下代码来阻塞除  
SIGKILL 和 SIGSTOP 之外的所有信号

sigfillset(&blockSet);
     if (sigprocmask(SIG_BLOCK, &blockSet, NULL) == -1){
        
            perror("sigprocmask");
            exit(EXIT_FAILURE);
        }

*  sigaction()和 sigprocmask()允许程序指定一组将由进程阻塞的信号

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

//  测试阻塞信号CTRL+C （SIGINT）
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <zconf.h>
    
    int main(int argc, char *argv[])
    {
        
        sigset_t set;
    
        sigemptyset(&set);
        sigaddset(&set,SIGINT);
        sigprocmask(SIG_SETMASK,&set,NULL);
    
        sleep(15);
    
        return 0;
    }

程序运行后，由于屏蔽了SIGINT信号，当按CTRL+C退出时程序无反应，直到15秒超时后程序退出

[root@localhost signal]# gcc -g sigprocmask.c -o sigprocmask
    [root@localhost signal]# ./sigprocmask
    ^C^C^C^C^C^C^C^C^C^C^C^C^C^C^C^C^C[root@localhost signal]#

在调用sigprocmask后如果有任何未决的、不再阻塞的信号，则在sigprocmask返回前，至少会将其中一个信号递送给该进程。

// 例子2 测试sigprocmask返回前，至少会将其中一个未决、不再阻塞的信号传递给该进程。
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    
    void sig_int(int signo)
    {
        
        printf("\nreceived SIGINT!\n");
    }
    
    int main()
    {
        
        sigset_t newmask,oldmask;
    
        if(signal(SIGINT,sig_int) == SIG_ERR)
            perror("signal(SIGINT) error!");
        sigemptyset(&newmask);
        sigaddset(&newmask,SIGINT);
        if(sigprocmask(SIG_BLOCK,&newmask,&oldmask) < 0)
            perror("sigprocmask(SIG_BLOCK) error!");
    
        sleep(5);
    
        if(sigprocmask(SIG_SETMASK,&oldmask,NULL) < 0)
            perror("sigprocmask(SIG_SETMASK) error!");
    
        return 0;
    }

第一个运行./sigprocmask1后，按键CTRL+C，发现没有进入信号处理函数，等待5s后，重新进入sigprocmask，此时会处理原来阻塞未决的CTRL+C信号，此时由于sigprocmask已经将SIGINTR信号设置为不阻塞，所以进程收到SIGINTR信号后进入信号处理函数，并打印出received。  
第二次运行./sigprocmask1后，不做任何处理，等待5s后退出。  
编译运行：

[root@localhost signal]# gcc -g sigprocmask1.c -o sigprocmask1
    [root@localhost signal]# ./sigprocmask1
    ^C^C
    received
    [root@localhost signal]# ./sigprocmask1
    [root@localhost signal]#

## 判断哪些信号被阻塞了：sigpending ##

如果某进程接受了一个该进程正在阻塞的信号，那么会将该信号填加到进程的等待信号集中。当（且如果）之后解除了对该信号的锁定时，会随之将信号传递给此进程。为了确定进程中处于等待状态(信号是设置为阻塞并处于未决状态的)的是哪些信号，可以使用 sigpending()（\*\*读取未决状态字（pending）信息 \*\*）

NAME
           sigpending - 检查未决的信号 
    
    SYNOPSIS
           #include <signal.h>
    
           int sigpending(sigset_t *set);

*  sigpending()系统调用为调用进程返回处于等待状态的信号集，并将其置于 set 指向的sigset\_t 结构中。

看个例子：

#include <stdio.h>
    #include <unistd.h>
    #include <sys/wait.h>
    #include <sys/time.h>
    #include <signal.h>
    
    int main(int argc, char *argv[])
    {
        
        while (true) {
        
            sigset_t pendest;
            sigpending(&pendest);
    
            for (int i = 0; i < 64; i++) {
            //每隔一秒，对系统信号阻塞集的信号做一次校验
                if (sigismember(&pendest, i))
                    printf("1");
                else
                    printf("0");
            }
    
            printf("\n"); 
            sleep(1);
        }
    
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]

#include <signal.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <stdio.h>
    
    
    
    void handler(int num)
    {
        
        if(num == SIGINT){
        
            printf("刚才收到了信号SIGQUIT, 取消了阻塞，收到中断信号..");
        }
        else if (num == SIGQUIT){
        
            //将SIGINT信号设置为非阻塞的
            sigset_t un_bset;
            sigemptyset(&un_bset);
            sigaddset(&un_bset, SIGINT);
            sigprocmask(SIG_UNBLOCK, &un_bset, NULL);
        }
    }
    
    void print_pending(sigset_t * pset)
    {
        
        int i = 0;
        printf( "未决状态字(64位)：");
        for (i = 1; i <= 64; ++i){
        
            if(sigismember(pset, i))
                printf("%d", 1);
            else
                printf("%d", 0);
            if(i % 8 == 0){
        
                printf(" ");
            }
        }
        printf("\n");
    }
    int main()
    {
        
        sigset_t bset;
        sigset_t pset;
    
        //设置SIGINT信号
        sigemptyset(&bset);
        sigaddset(&bset, SIGINT);
    
        signal(SIGINT, handler);
        signal(SIGQUIT, handler);
        //将SIGINT信号设置为阻塞的
        sigprocmask(SIG_BLOCK, &bset, NULL);
    
        while(1){
        
            //得到未决状态字
            sigpending(&pset);
            //显示未决状态字
            print_pending(&pset);
    
            sleep(1);
        }
    
    
        exit(0);
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]

如果修改了对等待信号的处置，那么当后来解除对信号的锁定时，将根据新的处置来处理信号。这项技术虽然不经常使用，但还是存在一个应用场景，即将对信号的处置置为SIG\_IGN，或者 SIG\_DFL（如果信号的默认行为是忽略），从而阻止传递处于等待状态的信号。因此，会将信号从进程的等待信号集中移除，从而不传递该信号。

#define _GNU_SOURCE
    #include <string.h>
    #include <signal.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    void printSigset(FILE *of, const char *prefix, const sigset_t *sigset){
        
        int sig = 0;
        int cnt = 0;
    
        for(sig = 1 ; sig < NSIG; sig ++){
        
            if (sigismember(sigset, sig)){
        
                cnt++;
                fprintf(of, "%s%d (%s)\n", prefix, sig, strsignal(sig));
            }
        }
    
        if (cnt == 0)
            fprintf(of, "%s<empty signal set>\n", prefix);
    }
    
    int                     /* Print mask of blocked signals for this process */
    printSigMask(FILE *of, const char *msg)
    {
        
        sigset_t currMask;
    
        if (msg != NULL)
            fprintf(of, "%s", msg);
    
        if (sigprocmask(SIG_BLOCK, NULL, &currMask) == -1)
            return -1;
    
        printSigset(of, "\t\t", &currMask);
    
        return 0;
    }
    
    int                     /* Print signals currently pending for this process */
    printPendingSigs(FILE *of, const char *msg)
    {
        
        sigset_t pendingSigs;
    
        if (msg != NULL)
            fprintf(of, "%s", msg);
    
        if (sigpending(&pendingSigs) == -1)
            return -1;
    
        printSigset(of, "\t\t", &pendingSigs);
    
        return 0;
    }

# 不对信号进行排队处理 #

等待信号集只是一个掩码，仅表明一个信号是否发生，而未表明其发生的次数。换言之，如果同一信号在阻塞的状态下产生多次，那么会将该信号记录在等待信号集中，并在稍后仅传递一次（标准信号与实时信号的差异之一是，实时信号进行了排队处理）

我们来看例子，观察未作排队处理的信号：

// sig_sender.c
    #define _GNU_SOURCE
    #include <string.h>
    #include <signal.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int
    main(int argc, char *argv[])
    {
        
        int numSigs, sig, j;
        pid_t pid;
    
        if (argc < 4 || strcmp(argv[1], "--help") == 0){
        
            printf("%s pid num-sigs sig-num [sig-num-2]\n", argv[0]);
            exit(0);
        }
    
    
        pid = atoi(argv[1]);
        numSigs = atoi(argv[2]);
        sig = atoi(argv[3]);
    
        /* Send signals to receiver */
    
        printf("%s: sending signal %d to process %ld %d times\n",
               argv[0], sig, (long) pid, numSigs);
    
        for (j = 0; j < numSigs; j++)
            if (kill(pid, sig) == -1){
        
                perror("kill");
                exit(EXIT_FAILURE);
            }
    
    
        /* If a fourth command-line argument was specified, send that signal */
    
        if (argc > 4)
            if (kill(pid, atoi(argv[4])) == -1){
        
                perror("kill");
                exit(EXIT_FAILURE);
            }
    
        printf("%s: exiting\n", argv[0]);
        exit(EXIT_SUCCESS);
    }

// sig_receiver.c
    #define _GNU_SOURCE
    #include <string.h>
    #include <signal.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <zconf.h>
    
    static int sigCnt[NSIG];                     /* Counts deliveries of each signal */
    static volatile sig_atomic_t gotSigint = 0;  /* Set nonzero if SIGINT is delivered */
    
    static void
    handler(int sig)
    {
        
        if (sig == SIGINT)
            gotSigint = 1; //处理器程序将对标志（gotSigint）置位，从而使程序退出主循环
        else
            sigCnt[sig]++;  //对于大多数类型的信号，处理器程序只是简单地使用一个数组来对信号计数。
    }
    void printSigset(FILE *of, const char *prefix, const sigset_t *sigset){
        
        int sig = 0;
        int cnt = 0;
    
        for(sig = 1 ; sig < NSIG; sig ++){
        
            if (sigismember(sigset, sig)){
        
                cnt++;
                fprintf(of, "%s%d (%s)\n", prefix, sig, strsignal(sig));
            }
        }
    
        if (cnt == 0)
            fprintf(of, "%s<empty signal set>\n", prefix);
    }
    int
    main(int argc, char *argv[])
    {
        
        int n, numSecs;
        sigset_t pendingMask, blockingMask, emptyMask;
    
        printf("%s: PID is %ld\n", argv[0], (long) getpid());
    
        /* Here we use the simpler signal() API to establish a signal handler,
           but for the reasons described in Section 22.7 of TLPI, sigaction()
           is the (strongly) preferred API for this task. */
    
        for (n = 1; n < NSIG; n++)          /* 所有信号使用相同的处理程序  */
            (void) signal(n, handler);      /* 忽略错误  */
    
        /* 如果指定了睡眠时间，请暂时阻止所有信号，然后进入睡眠状态（另一个进程向我们发送信号），
         * 然后显示未决信号的掩码并取消阻止所有信号 */
    
        if (argc > 1) {
        
            numSecs = atoi(argv[1]);
    
            sigfillset(&blockingMask);
            if (sigprocmask(SIG_SETMASK, &blockingMask, NULL) == -1){
          //阻塞除SIGKILL 和 SIGSTOP 之外的所有信号
                perror("sigprocmask");
                exit(EXIT_FAILURE);
            }
    
    
            printf("%s: sleeping for %d seconds\n", argv[0], numSecs);
            sleep(numSecs);      //程序对所有信号的阻塞秒数将由numSecs指定
    
            if (sigpending(&pendingMask) == -1){
          // 返回处于等待状态的信号集
                perror("sigpending");
                exit(EXIT_FAILURE);
            }
    
            printf("%s: pending signals are: \n", argv[0]);
            printSigset(stdout, "\t\t", &pendingMask);  //在解除阻塞之前会显示待处理的信号集
    
            sigemptyset(&emptyMask);        /* Unblock all signals */
            if (sigprocmask(SIG_SETMASK, &emptyMask, NULL) == -1){
        
                perror("sigemptyset");
                exit(EXIT_FAILURE);
            }
    
        }
    
        while (!gotSigint)                  /* Loop until SIGINT caught */
            continue;
    
        for (n = 1; n < NSIG; n++)          /* 退出 while 循环后，程序显示对所有接收信号的计数。*/
            if (sigCnt[n] != 0)
                printf("%s: signal %d caught %d time%s\n", argv[0], n,
                       sigCnt[n], (sigCnt[n] == 1) ? "" : "s");
        exit(EXIT_SUCCESS);
    }

上面sig\_sender接受四个命令行参数：

./sig_sender PID num-sigs sig-num [sig-num-2]

*  第一个参数是程序发送信号的目标进程 ID。
 *  第二个参数则指定发送给目标进程的信号数量
 *  第三个参数指定发往目标进程的信号编号。
 *  如果还提供了一个信号编号作为第四个参数，那么就使用最后一个参数向目录进程发送一个SIGINT信号  
    ![在这里插入图片描述][20210527141148225.png]  
    上面的./sig\_receiver指定了一个睡眠间隔15，必须在醒来之前发送所有的信号，负责这个程序就终止了。

./reg\_sender的命令行参数指定了 SIGUSR1 和 SIGINT 信号，其在 Linux/x86 中的编号分别  
为 10 和 2。

从上面输出可知，即使一个信号发送了一百万次，但仅会传递一次给接收者。

![在这里插入图片描述][20210527141949564.png]  
即使进程没有阻塞信号，其所收到的信号也可能比发送给它的要少得多。如果信号发送速度如此之快，以至于在内核考虑将执行权调度给接收进程之前，这些信号就已经到达，这时就会发生上述情况，从而导致多次发送的信号在进程等待信号集中只记录了一次。

从上面可以可看出，在所发送的一百万次信号之中，接收进程仅捕获到 52 次。原因在于，发送程序会在每次获得调度而运行时发送多个信号给接受者。然而，当接受进程得以运行时，传递来的信号只有一个，因为只会将这些信号中的一个标记为等待状态

**同一种信号多次发生，通常并不对它们排队，所以如果在某种信号被阻塞时它发生了五次，那么对这种信号解除阻塞后，其信号处理函数通常只会被调用一次。**

#include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <unistd.h>
    static void sig_int(int);
    
    int main(void)
    {
        
        if(signal(SIGINT,sig_int) == SIG_ERR)
            perror("can't catch SIGINT\n");
    
        for(;;)
            pause;
    }
    
    void sig_int(int signo)
    {
        
        printf("received SIGINT\n");
        sleep(10);
        printf("after sleep 10s\n");
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]

> 如果信号在被解除之前，发送了很多次，系统是如果处理呢？

POSIX.1允许系统递送该信号一次或多次。如果递送该信号多次，则称对这些信号进行了排队。但大多数UNIX不对信号排队，而是只递送一次这种信号。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221119/7206ec369ecd43199b0ec8f0376f1d17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210110214827418.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210110215205504.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210110212544493.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[20210527141148225.png]: https://img-blog.csdnimg.cn/20210527141148225.png
[20210527141949564.png]: https://img-blog.csdnimg.cn/20210527141949564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210110123817133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70