『Linux从入门到精通』第 ㉗ 期 - 阻塞信号 & 捕捉信号 & 总结

💐专栏导读

🌸作者简介：花想云 ，在读本科生一枚，C/C++领域新星创作者，新星计划导师，阿里云专家博主，CSDN内容合伙人…致力于 C/C++、Linux 学习。

🌸专栏简介：本文收录于 Linux从入门到精通，本专栏主要内容为本专栏主要内容为Linux的系统性学习，专为小白打造的文章专栏。

🌸相关专栏推荐：C语言初阶系列、C语言进阶系列 、C++系列、数据结构与算法。

💐文章导读

本章我们将继续学习Linux中信号的概念——阻塞信号、捕捉信号、可重入函数、volatile关键字、SIGCHLD信号等。

🐧阻塞信号

🐦信号其他常见概念

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

🐦信号在内核值中的表示

• 每个信号都有两个标志位分别表示阻塞（block）和未决（pending），还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才消除该标志。在上图的例子中，SIGHUP信号既未被阻塞也未产生；
• SIGINT信号已产生但正在被阻塞，所以暂时不能递达。虽然它的默认动作是忽略（SIG_IGN），但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞；
• SIGOUT信号未产生，一旦该信号产生将会被阻塞，它的处理动作是用户自定义函数sighandler 。如果在进程解除对某信号的阻塞之前这种信号产生过多次，将如何处理？POSIX.1 允许系统递送该信号一次或多次。Linux 是这样实现的：常规信号在递达之前产生多次只记录一次，而实时信号在递达之前产生多次可以依次放在一个队列里。

🐦sigset_t

从上图来看，每个信号只有一个bit 的未决位，非0即1，并不记录信号产生了多少次，阻塞标志也是这样表示的。因此，未决和阻塞标志可以用相同的数据类型sigset_t 来存储，sigset_t称为信号集，这个类型可以表示每个信号的有效或无效状态，在阻塞信号集中有效和无效的含义是该信号是否被阻塞，而在未决信号集中的有效或无效的含义是该信号是否处于未决状态。阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里的”屏蔽“应该理解为阻塞而不是忽略。

🐦信号集操作函数

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

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember（const sigset_t *set, int signo);

1. sigemptyset:

   • 功能： 清空信号集合。
   • 参数： set是一个指向sigset_t类型的指针，用于表示信号集合。

2. sigfillset:

   • 功能： 将信号集合设置为包含所有可能的信号。
   • 参数： set是一个指向sigset_t类型的指针，用于表示信号集合。

3. sigaddset:

   • 功能： 将指定的信号添加到信号集合中。
   • 参数：
     • set是一个指向sigset_t类型的指针，用于表示信号集合。
     • signo是要添加的信号编号。

4. sigdelset:

   • 功能： 从信号集合中删除指定的信号。
   • 参数：
     • set是一个指向sigset_t类型的指针，用于表示信号集合。
     • signo是要删除的信号编号。

5. sigismember:

   • 功能： 检查指定的信号是否包含在信号集合中。
   • 参数：
     • set是一个指向sigset_t类型的指针，用于表示信号集合。
     • signo是要检查的信号编号。
   • 返回值： 如果信号在集合中，返回非零值；否则返回0。

这四个函数都是成功返回0,出错返回-1。

🐱sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
// 返回值:若成功则为0,若出错则为-1

• 如果oset是非空指针，则读取进程的当前信号屏蔽字通过oset参数传出。

• 如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改。

• 如果oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask，下表说明了how参数的可选值。

如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask返回前，至少将其中一个信号递达。

🐱sigpending

#include <signal.h>
int sigpending(sigset_t *set);
// 如果成功，返回 0。如果失败，返回 -1，并设置 errno 来指示错误类型

sigpending 用来获取当前被阻塞的、正在等待处理的信号集合。参数 set 是一个指向 sigset_t 类型的指针，用于存储获取到的信号集合。sigpending 函数通常用于在信号处理程序中查询当前正在排队等待处理的信号，以便根据需要执行适当的操作。

🐱代码示例

接下来我们同过一个小案例来将几个函数使用一下。案例：我们先将2号信号也就是ctrl c 进行屏蔽，然后循环打印pending位图。紧接着我们按下ctrl c 向进程发送2号信号，由于2号信号被屏蔽，所以2号信号一直处于未决状态，不会被递达。在5秒过后，再取消对2号信号的屏蔽，这时2号信号递达被处理，再次查看pending位图，发现2号信号的比特位被置0。

#include <iostream>
#include <cassert>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

void PrintPending(const sigset_t &pending)
{
    cout << "当前进程的pending位图：";
    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void headler(int signo)
{
    cout << "接收到信号：" << signo << endl;
    int cnt = 30;
    while (cnt--)
    {
        sigset_t pending;
        sigemptyset(&pending);
        sigpending(&pending);
        PrintPending(pending);
        sleep(1);
    }
    exit(1);
}
int main()
{
    signal(SIGINT, headler);
    int cnt = 0;
    // 1.屏蔽2号信号
    sigset_t set, oset;
    // 1.1初始化
    sigemptyset(&set);
    sigemptyset(&oset);
    // 1.2将2号信号添加到set中
    sigaddset(&set, SIGINT);
    // 1.3 将新的信号屏蔽字设入进程
    sigprocmask(SIG_BLOCK, &set, &oset);

    // 2. while获取进程的pending信号集合，并打印
    while (true)
    {
        // 2.1 获取pending信号集
        sigset_t pending;
        sigemptyset(&pending);
        int n = sigpending(&pending);
        assert(n == 0);
        (void)n;
        // 2.2 打印
        PrintPending(pending);
        sleep(1);
        if (cnt++ == 5)
        {
            cout << "解除对2号信号的屏蔽" << endl;
            sigprocmask(SIG_SETMASK, &oset, nullptr);
        }
    }
    return 0;
}

🐧捕捉信号

我们之前提到信号的产生相对于进程是异步的，当信号产生时，当前进程可能在处理更重要的事情，那么这个信号递达之后，进程可能并不会立刻执行该信号的执行动作。而是在进程从内核态切回用户态的时候，进程会在OS的指导下，进行信号的检测与处理。

什么是内核态与用户态？
内核态（Kernel Mode）和用户态（User Mode）是操作系统中两种不同的运行模式，用于区分操作系统内核的执行上下文和应用程序的执行上下文。这两种模式之间的切换是操作系统的核心概念之一。

1. 内核态（Kernel Mode）：

   • 在内核态下，操作系统内核拥有对计算机硬件的完全访问权限。内核可以执行特权指令，访问所有的内存地址和设备，以及执行一些敏感的指令，如修改中断向量表和处理中断。
   • 内核态通常用于执行操作系统内核的代码，处理系统级的任务，例如进程调度、内存管理、文件系统操作等。
   • 只有在内核态下，操作系统才能执行对硬件的底层操作。

2. 用户态（User Mode）：

   • 在用户态下，应用程序只能访问被允许的内存区域和受限的指令集。应用程序不能直接访问硬件设备或执行特权指令。
   • 大多数应用程序在用户态下运行，执行用户级任务，如数据处理、图形界面等。
   • 当应用程序需要执行系统级任务时，例如请求文件读取或写入、申请内存空间等，会通过系统调用（system call）切换到内核态，请求操作系统内核的帮助。

3. 用户态到内核态的切换：

   • 用户态和内核态之间的切换是由操作系统控制的。当发生系统调用、中断、异常等事件时，CPU会从用户态切换到内核态，执行相应的内核代码。完成内核态的任务后，CPU再切换回用户态，继续执行应用程序代码。
   • 切换涉及到保存和恢复上下文信息，确保在切换后程序的状态能够得到正确的恢复。

通过将操作系统内核与用户应用程序隔离在不同的执行模式中，可以提高系统的稳定性和安全性。内核态的权限较高，只有经过仔细设计和验证的内核代码才能在该模式下执行，从而减少了对系统的滥用和错误操作。

🐦内核如何完成对信号的捕捉

如果信号的处理动作是用户自定义函数，在信号递达时就调用这个函数，这称为捕捉信号。由于信号处理函数的代码是在用户空间的，处理过程比较复杂，举例如下：

• 用户程序注册了SIGQUIT信号的处理函数sighandler。 当前正在执行main函数，这时发生中断或异常切换到内核态。
• 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。
• 内核决定返回用户态后不是恢复main函数的上下文继续执行，而是执行sighandler函数，sighandler和main函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程。
• sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。

🐦sigaction

sigaction 是一个用于设置和检查信号处理函数的系统调用，用于在程序中对信号进行自定义处理。在 Unix 和类 Unix 操作系统中，sigaction 提供了更灵活和可控的信号处理方式，相较于旧的 signal 函数而言更为强大。

以下是 sigaction 函数的基本形式：

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

• 功能： 用于设置或检查信号的处理方式。

• 参数：

  • signum 是要处理的信号编号。
  • act 是一个指向 struct sigaction 结构的指针，用于指定新的信号处理方式。
  • oldact 是一个指向 struct sigaction 结构的指针，用于获取之前的信号处理方式（可以为 NULL，表示不获取之前的处理方式）。

• 返回值：

  • 如果成功，返回 0。
  • 如果出错，返回 -1，并设置 errno 来指示错误类型。

• struct sigaction 结构：

  struct sigaction {
      void (*sa_handler)(int);
      void (*sa_sigaction)(int, siginfo_t *, void *);
      sigset_t sa_mask;
      int sa_flags;
  };
  

  • sa_handler：用于指定信号处理函数的地址。
  • sa_sigaction：用于指定带有三个参数的信号处理函数的地址（优先于 sa_handler）。
  • sa_mask：指定在信号处理函数执行期间需要被屏蔽的信号集。
  • sa_flags：用于指定一些标志，例如 SA_RESTART 表示在系统调用中自动重启被信号中断的系统调用。
  • 将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号，赋值为常数SIG_DFL表示执行系统默认动作。

当某个信号的处理函数被调用时，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，如果这种信号再次产生，那么它会被阻塞到当前处理结束为止。

如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项，本章的代码都把sa_flags设为0，sa_sigaction是实时信号的处理函数，本章不详细解释这两个字段。

代码示例

#include <iostream>
#include <cassert>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

void PrintPending(const sigset_t &pending)
{
    cout << "当前进程的pending位图：";
    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void headler(int signo)
{
    cout << "接收到信号：" << signo << endl;
    int cnt = 30;
    while (cnt--)
    {
        sigset_t pending;
        sigemptyset(&pending);
        sigpending(&pending);
        PrintPending(pending);
        sleep(1);
    }
    exit(0);
}
int main()
{
    struct sigaction act, oldact;
    memset(&act, 0, sizeof(act));
    memset(&oldact, 0, sizeof(oldact));
    act.sa_handler = headler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    // 在处理2号信号的时候屏蔽3、4、5号信号
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);
    sigaddset(&act.sa_mask, 5);

    sigaction(2, &act, &oldact);

    while (true)
    {
        cout << getpid() << endl;
        sleep(1);
    }
    return 0;
}

🐧可重入函数

先看一个例子：

main函数调用insert函数向一个链表head中插入节点node1，插入操作分为两步，刚做完第一步的时候，因为硬件中断使进程切换到内核，再次回用户态之前检查到有信号待处理，于是切换到sighandler函数，sighandler也调用insert函数向同一个链表head中插入节点node2，插入操作的两步都做完之后从sighandler返回内核态，再次回到用户态就从main函数调用的insert函数中继续往下执行，先前做第一步之后被打断，现在继续做完第二步。结果是，main函数和sighandler先后向链表中插入两个节点，而最后只有一个节点真正插入链表中了。

像上例这样，insert函数被不同的控制流程调用，有可能在第一次调用还没返回时就再次进入该函数，这称为重入，insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数称为不可重入函数。

反之,如果一个函数只访问自己的局部变量或参数，则称为可重入(Reentrant) 函数。

🐧volatile

volatile 为C语言中的一个关键字，但是学了这么久C语言，我们可能都并没怎么用过它，下面我们就介绍一下这个关键字。

#include <stdio.h>
#include <signal.h>

int quit = 0;

void handler(int signo)
{
  printf("change quit from 0 to 1\n");
  quit = 1;
  printf("quit : %d\n", quit);
}

int main()
{
  signal(2, handler);
  
  while(!quit);

  printf("main quit securely\n");

  return 0;
}

在正常情况下，当我们按下ctrl c，2号信号被捕捉，执行自定义动作，修改quit = 1，while条件不满足，退出循环，进程退出。

当我们提高编译器的优化等级，再次实验；

$ gcc -o test test.c -O2
$ ./test

优化情况下，键入 CTRL-C ，2号信号被捕捉，执行自定义动作，修改 flag＝1 ，但是 while 条件依旧满足，进程继续运行！但是很明显quit肯定已经被修改了，但是为何循环依旧执行？很明显， while 循环检查的quit，并不是内存中最新的quit，这就存在了数据二异性的问题。 这是因为while 检测的quit其实已经因为被优化，被放在了CPU寄存器当中。

关于编译器优化等级

编译器优化等级是在编译源代码时选择的一组优化策略的级别。通过调整优化等级，程序员可以在编译时控制编译器对生成的目标代码进行优化的程度。在编译器中，通常有多个优化等级，例如 -O0、-O1、-O2、-O3 等。每个等级都代表了一组不同的优化策略，其目标是提高程序的执行效率、减小代码体积或者兼顾两者。

以下是常见的编译器优化等级及其一般特点：

1. -O0（无优化）：

   • 不进行任何优化，生成容易调试的代码。
   • 编译速度最快，生成的目标代码可读性较好，用于调试目的。

2. -O1（基本优化）：

   • 执行一组基本的优化，包括一些常见的优化技术，如删除未引用的变量、简化表达式等。
   • 生成相对较快的目标代码，但仍保留较好的调试信息。

3. -O2（中级优化）：

   • 包含更多的优化策略，可能会涉及到循环展开、内联函数、常量传播等。
   • 生成更高效的目标代码，但可能会牺牲一些调试信息。

4. -O3（高级优化）：

   • 启用更多的高级优化技术，如向量化、循环变换等。
   • 目标是生成最高效的目标代码，但可能会影响可读性，并且在某些情况下可能引入一些不稳定性。

5. 其他优化等级：

   • 编译器还可能支持其他优化等级，如 -Os（优化大小）和 -Og（适度优化，用于开发时期的调试）等。

编译器优化等级的选择通常需要平衡程序的执行速度和生成的目标代码大小。在开发过程中，一般建议使用较低的优化等级以保留更多的调试信息，而在最终发布版本中使用更高的等级以获得更好的性能。在一些特殊情况下，程序员可能会根据具体需求手动调整优化选项。

那么如何防止编译器自作聪明的优化呢？这就要用到volatile关键字了。

• volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作。

#include <stdio.h>
#include <signal.h>

volatile int quit = 0;

void handler(int signo)
{
  printf("change quit from 0 to 1\n");
  quit = 1;
  printf("quit : %d\n", quit);
}

int main()
{
  signal(2, handler);
  
  while(!quit);

  printf("main quit securely\n");

  return 0;
}

🐧SIGCHLD信号

进程一章讲过用wait和waitpid函数清理僵尸进程，父进程可以阻塞等待子进程结束，也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式，父进程阻塞了就不能处理自己的工作了；采用第二种方式，父进程在处理自己的工作的同时还要记得时不时地轮询一 下，程序实现复杂。

其实，子进程在终止时会给父进程发SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需专心处理自己的工作，不必关心子进程了，子进程 终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。

代码示例

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

pid_t id;

void waitProcess(int signo)
{
    printf("捕捉到一个信号: %d, who: %d\n", signo, getpid());
    sleep(5);

    // 5个退出，5个没退
    while (1)
    {
        pid_t res = waitpid(-1, NULL, WNOHANG);
        if (res > 0)
        {
            printf("wait success, res: %d, id: %d\n", res, id);
        }
        else break; // 如果没有子进程了？
    }

    printf("handler done...\n");
}

int main()
{
	// 方法一，设置自定义方法回收子进程
    signal(SIGCHLD, waitProcess);
    int i = 1;
    for (; i <= 10; i++)
    {
        id = fork();
        if (id == 0)
        {
            // child
            int cnt = 5;
            while (cnt)
            {
                printf("我是子进程, 我的pid: %d, ppid: %d\n", getpid(), getppid());
                sleep(1);
                cnt--;
            }

            exit(1);
        }
    }
    // 如果你的父进程没有事干，你还是用以前的方法
    // 如果你的父进程很忙，而且不退出，可以选择信号的方法
    while (1)
    {
        sleep(1);
    }

    return 0;
}

事实上，由于UNIX 的历史原因，要想不产生僵尸进程还有另外一种办法：父进程调用sigaction将SIGCHLD的处理动作置为SIG_IGN，这样 fork 出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程。系统默认的忽略动作和用户用sigaction函数自定义的忽略通常是没有区别的，但这是一个特例。此方法对于 Linux 可用，但不保证在其它 UNIX 系统上都可用。

代码示例

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

pid_t id;

int main()
{
    signal(SIGCHLD, SIG_IGN);

    int i = 1;
    for (; i <= 10; i++)
    {
        id = fork();
        if (id == 0)
        {
            // child
            int cnt = 5;
            while (cnt)
            {
                printf("我是子进程, 我的pid: %d, ppid: %d\n", getpid(), getppid());
                sleep(1);
                cnt--;
            }
            exit(1);
        }
    }
    // 如果你的父进程没有事干，你还是用以前的方法
    // 如果你的父进程很忙，而且不退出，可以选择信号的方法
    while (1)
    {
        sleep(1);
    }

    return 0;
}