1. 进程信号

1.1 进程信号的概念

信号是一个软件中断，通知进程某个事件发生了异步事件，打断进程当前的操作，去处理这个事件，信号是多种多样的，并且一个信号对应一个事件，这样才能做到进程收到一个信号后，知道是什么事件，应该如何去处理

1.2 信号的查看

（1）使用 kill -l 命令查看信号种类

（2）信号一共有62种，其中：

• 1-31号信号都是非可靠信号（从unix借鉴而来，每个信号都有具体对应的系统事件，有可能会信号丢失）
• 34-64号信号 都是可靠信号（没有具体对应的事件，不会丢失信号）

信号	说明
SIGHUP	当用户退出shell 时，由该shell 启动的所有进程将收到这个信号，默认动作为终止进程。
SIGINT	当用户按下了<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程。
SIGQUIT	当用户按下<ctrl+>组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号。默认动作为终止进程。
SIGILL	CPU 检测到某进程执行了非法指令。默认动作为终止进程并产生core 文件
SIGTRAP	该信号由断点指令或其他 trap 指令产生。默认动作为终止里程 并产生 core 文件。
SIGABRT	调用abort 函数时产生该信号。默认动作为终止进程并产生 core 文件。
SIGBUS	非法访问内存地址，包括内存对齐出错，默认动作为终止进程并产生 core 文件。
SIGFPE	在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为 0 等所有的算法错误。默认动作为终止进程并产生 core 文件。
SIGKILL	无条件终止进程。本信号不能被忽略，处理和阻塞。默认动作为终止进程。它向系统管理员提供了可以杀死任何进程的方法。
SIGUSE1	用户定义 的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程。
SIGSEGV	指示进程进行了无效内存访问。默认动作为终止进程并产生 core 文件。
SIGUSR2	另外一个用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。
SIGPIPE	Broken pipe 向一个没有读端的管道写数据。默认动作为终止进程。
SIGALRM	定时器超时，超时的时间 由系统调用alarm 设置。默认动作为终止进程。
SIGTERM	程序结束信号，与 SIGKILL 不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。执行 shell 命令Kill 时，缺省产生这个信号。默认动作为终止进程。
SIGSTKFLT	Linux 早期版本出现的信号，现仍保留向后兼容。默认动作为终止进程。
SIGCHLD	子进程状态发生变化时，父进程会收到这个信号。默认动作为忽略这个信号。
SIGCONT	如果进程已停止，则使其继续运行。默认动作为继续/忽略。
SIGSTOP	停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为暂停进程。
SIGTSTP	停止终端交互进程的运行。按下<ctrl+z>组合键时发出这个信号。默认动作为暂停进程。
SIGTTIN	后台进程读终端控制台。默认动作为暂停进程。
SIGTTOU	该信号类似于 SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程。
SIGURG	套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达，默认动作为忽略该信号。
SIGXCPU	进程执行时间超过了分配给该进程的CPU 时间 ，系统产生该信号并发送给该进程。默认动作为终止进程。
SIGXFSZ	超过文件的最大长度设置。默认动作为终止进程。
SIGVTALRM	虚拟时钟超时时产生该信号。类似于 SIGALRM，但是该信号只计算该进程占用 CPU 的使用时间。默认动作为终止进程。
SGIPROF	类似于SIGVTALRM，它不公包括该进程占用 CPU 时间还包括执行系统调用时间。默认动作为终止进程。
SIGWINCH	窗口变化大小时发出。默认动作为忽略该信号。
SIGIO	此信号向进程指示发出了一个异步IO 事件。默认动作为忽略。
SIGPWR	关机。默认动作为终止进程。
SIGSYS	无效的系统调用。默认动作为终止进程并产生 core 文件。

1.3 signal函数

#include <signal.h>

typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

signal 函数的功能：
函数 signal函数可以用来设置指定信号的处理函数。即修改特定进程对于信号的处理动作。当进程接收到该信号时，操作系统会自动调用该处理函数。信号处理函数可以是用户自定义的函数，也可以是系统提供的默认函数。

1.4 信号的生命周期

信号产生->在进程中注册->在进程中注销->捕捉处理（从信号发送到信号处理函数执行完毕）

1.5 信号的处理

信号的处理方式有三种，分别是：忽略、捕捉和默认动作。

1. 忽略信号
   大多数信号都可以采用这个方式进行处理，但有两种信号不能被忽略（即SIGKILL和SIGSTOP）。因为它们向内核和超级用户提供了进程终止和停止的可靠方法。如果忽略了，那么这个要处理的进程就变成了没人能管理的进程，显然是内核设计者不希望看到的场景。

2. 捕捉信号
   捕捉信号，就是需要告诉内核用户希望如何处理某一种信号，其实就是写一个信号处理的函数，然后将这个函数告诉内核。当该信号产生时，内核来调用用户自定义的函数，以此来达到处理信号的目的。

3. 系统默认
   对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。

1.6 注意

1. Ctrl + C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行，这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
2. Shell可以同时运行一个前台进程和任意多个后台进程，只有前台进程才能接到像 Ctrl + C 这种控制键产生的信号。
3. 前台进程在运行过程中用户随时可能按下 Ctrl + C 而产生一个信号，也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止，所以信号相对于进程的控制流程来说是异步(Asynchronous)的。

2. 信号的产生

我们平常在Linux系统下所写的程序遇到死循环等问题时，退不出来， 常用组合键有：ctrl+c、ctrl+z、ctrl + \ 、kill + 进程的pid解决，这里的这些组合键盘输入就是产生了一个信号，以死循环程序为例说明：

#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
    while(1)
    {
        cout << "我是一个死循环: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

2.1 通过终端按键产生信号

（1）ctrl + c 产生的是 2号（SIGINT）终止信号，终止正在运行的前台进程，对后台进程无效。

①前台进程在运行过程中用户随时可能按下 ctrl+c产生一个信号，该进程的用户空间代码执行到任何地方都有可能收到 SIGINT信号而终止，所以信号对于进程来说是异步的。

②验证ctrl + c 产生的是2号信号：
这就需要用到上面介绍的signal函数来进行，代码演示：

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void handler(int sgno)
{
    cout << "我是" << sgno << "信号" << endl;
}

int main()
{
    signal(2, handler);
    
    while(1)
    {
        cout << "我是一个死循环: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

③运行结果：

（2）ctrl + z 产生的是 20号（SIGTSTP）暂停信号，暂停正在运行的前台进程。

①查看后台进程结果：

状态 T 表示是停止状态，可以通过发送 SIGCONT 信号让进程继续运行。（进程的详细信息的查看可以参考本篇博客）

②验证ctrl + z 产生的是20号信号，代码演示：

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void handler(int sgno)
{
    cout << "我是" << sgno << "信号" << endl;
}

int main()
{
    signal(20, handler);

    while(1)
    {
        cout << "我是一个死循环: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

③运行结果：

（3）ctrl + \ 产生的是 3号（SIGQUIT）退出信号，退出正在运行的进程。

①验证ctrl + \ 产生的是3号信号，代码演示：

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void handler(int sgno)
{
    cout << "我是" << sgno << "信号" << endl;
}

int main()
{
    signal(3, handler);

    while(1)
    {
        cout << "我是一个死循环: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

②运行结果：

（4）注意：有些信号是不允许使用signal函数来进行自定义动作的，比如19（SIGSTOP）就不允许被修改。

（5）通过查看man 7 signal 也可以发现按ctrl + c实际上是向进程发送2号信号SIGINT，而按ctrl + \实际上是向进程发送3号信号SIGQUIT，ctrl + z也一样。查看这两个信号的默认处理动作，可以看到这两个信号的Action是不一样的，2号信号是Term，而3号信号是Core。

Term和Core都代表着终止进程，但是Core在终止进程的时候会进行一个动作，那就是核心转储。

（6）核心转储的概念：
核心转储（core dump），在汉语中有时戏称为吐核，是操作系统在进程收到某些信号而终止运行时，将此时进程地址空间的内容以及有关进程状态的其他信息写出的一个磁盘文件。

①在云服务器中，核心转储是默认被关掉的，我们可以通过使用ulimit -a命令查看当前资源限制的设定。

②我们可以发现第一行是core文件的大小，它的默认大小被设定为0，因此就相当于关闭了核心转储的功能。我们可以通过ulimit -c size命令来设置core文件的大小。

③此时我们再次运行程序，并用ctrl + \终止。就会发现终止进程后会显示core dumped。

并且会在当前路径下生成一个core文件，该文件以一串数字为后缀，而这一串数字实际上就是发生这一次核心转储的进程的PID。

（7）核心转储的功能：
当我们的代码出错了，我们最关心的是我们的代码是什么原因出错的。如果我们的代码运行结束了，那么我们可以通过退出码来判断代码出错的原因，而如果一个代码是在运行过程中出错的，那么我们也要有办法判断代码是什么原因出错的。

当我们的程序在运行过程中崩溃了，我们一般会通过调试来进行逐步查找程序崩溃的原因。而在某些特殊情况下，我们会用到核心转储，核心转储指的是操作系统在进程收到某些信号而终止运行时，将该进程地址空间的内容以及有关进程状态的其他信息转而存储到一个磁盘文件当中，这个磁盘文件也叫做核心转储文件，一般命名为core.pid。

①而核心转储的目的就是为了在调试时，方便问题的定位。我们用下面这段代码进行演示：

#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
    printf("Hello Linux...\n");
    sleep(3);
    int a = 1 / 0;

    return 0;
}

②该代码当中出现了除0错误，该程序运行3秒后便会崩溃。

③使用gdb对当前可执行程序进行调试，然后直接使用core-file core文件命令加载core文件，即可判断出该程序在终止时收到了8号信号，并且定位到了产生该错误的具体代码。

说明：事后用调试器检查core文件以查清错误原因，这种调试方式叫做事后调试。

（8）core dump 标志：
此时我们回忆前面所学习的【进程控制】中的获取子进程的退出码部分。

进程等待函数waitpid函数的第二个参数：

pid_t waitpid(pid_t pid, int *status, int options);

waitpid函数的第二个参数status是一个输出型参数，用于获取子进程的退出状态。status是一个整型变量，但status不能简单的当作整型来看待，status的不同比特位所代表的信息不同，具体细节如下（只关注status低16位比特位）：

若进程是正常终止的，那么status的次低8位就表示进程的退出状态，即退出码。若进程是被信号所杀，那么status的低7位表示终止信号，而第8位比特位是core dump标志，即进程终止时是否进行了核心转储。

打开Linux的核心转储功能，通过以下的程序查看core dump 的标志位信息。代码中父进程使用fork函数创建了一个子进程，子进程所执行的代码当中存在野指针问题，当子进程执行到*p = 1000时，必然会被操作系统所终止并在终止时进行核心转储。此时父进程使用waitpid函数便可获取到子进程退出时的状态，根据status的第7个比特位便可得知子进程在被终止时是否进行了核心转储。

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

using namespace std;

int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        //子进程
        int *p = nullptr;
        *p = 1000;

        exit(1);
    }

    //父进程
    int status = 0;
    waitpid(id, &status, 0);
    printf("exit code %d, sigo: %d, core dump flag: %d\n", (status >> 8) & 0xFF, (status >> 7) & 0x7F, (status >> 7) & 0x1);

    return 0;
}

如下图可以看到，所获取的status的第7个比特位为1，即可说明子进程在被终止时进行了核心转储。

因此，core dump标志实际上就是用于表示程序崩溃的时候是否进行了核心转储。

2.2 通过调用系统函数产生信号

1. kill函数可以给一个指定的进程发送指定的信号

int kill(pid_t pid, int sig);

参数：

• pid：进程的pid。
• sig：给进程要发送几号信号。

kill + pid 默认发送15号信号。 本质上就是向一个进程发送了终止信号，进程收到这个信号并且处理才会退出。如果对于处在停止状态的进程， 进程没有在运行，意味着不会去处理这个信号，所以 kill + pid 不能终止处于停止状态的进程（kiil -9 + pid 不在讨论范围）。

2. raise函数可以给当前进程发送指定信号

函数原型：

int raise(int sig);

raise函数用于给当前进程发送信号，发送成功返回0，发送失败则返回非0。例如，下列代码当中用raise函数每隔一秒向自己发送一个2号信号。

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

using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，获取了" << signo << "信号"  << "  " << cnt << endl;
}

int main()
{
    signal(2, handler);

    while(true)
    {
        cnt++;
        raise(2);

        sleep(1);
    }
    
    return 0;
}

运行结果就是该进程每隔一秒收到一个2号信号：

3. abort 函数给当前进程发送 SIGABRT（6号） 信号，使当前进程收到信号后异常终止， 通常用于异常通知

函数原型：

void abort();

abort函数使当前进程接收到信号而异常终止。就像exit函数一样,abort函数总是会成功的,所以没有返回值。

①如下程序，运行5秒后调用abort终止程序。

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

using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，获取了" << signo << "信号"  << "  " << cnt << endl;
}

int main()
{
    signal(2, handler);

    while (true)
    {
        sleep(1);
        cnt++;

        if (cnt == 5)
        {
            abort();
        }
    }
    
    return 0;
}

②运行结果：

【注意】
abort函数的作用是异常终止进程，exit函数的作用是正常终止进程，而abort本质是通过向当前进程发送SIGABRT信号而终止进程的，因此使用exit函数终止进程可能会失败，但使用abort函数终止进程总是成功的。

注意：raise函数和abort函数其实就是对kill的封装。

2.3 通过软件条件产生信号

2.3.1 SIGPIPE信号

SIGPIPE信号是一种由软件条件产生的信号，当进程在使用管道通信时，如果读端进程将读端关闭后，另一个进程还在不断向管道写入数据，那么此次写端进程就会收到SIGPIPE信号而终止程序。

如下的一段代码来模拟以上这种情况，创建管道进行父子进程间通信，其中父进程是读端，子进程是写端，但父进程关闭了自己的读端，那么此时子进程在向管道写入数据时就会收到SIGPIPE信号，进而被终止。

#include <iostream>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;

int main()
{
    int fd[2] = {0};
    if (pipe(fd) < 0)
    {
        cerr << "pipe error" << endl;
        exit(1);
    }

    pid_t id = fork();
    if (id == 0)
    {
        //子进程 --- 写端
        close(fd[0]);
        const char *msg = "父进程你好，我是子进程...";

        int count = 5;
        while (count)
        {
            write(fd[1], msg, strlen(msg));
            sleep(1);
            count--;
        }

        close(fd[1]);
        exit(0);
    }

    //父进程 --- 读端
    close(fd[1]);

    close(fd[0]); //父进程关闭自己的写端，导致子进程写入会被操作系统终止

    int status = 0;
    waitpid(id, &status, 0);

    cout << "子进程收到信号：" << (status & 0x7F) << endl;

    return 0;
}

运行结果：

2.3.2 alarm函数

（1）alarm 函数，等待设置的时钟周期后， 向进程发送SIGALRM 信号， 该信号的默认处理是终止当前进程。函数原型如下：

int alarm(int seconds)

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。打个比方,某人要小睡一觉，设定闹钟为30分钟之后响，20分钟后被人吵醒了，还想多睡一会儿，于是重新设定闹钟为15分钟之后响，“以前设定的闹钟时间还余下的时间”就是10分钟。如果seconds值为0，表示取消以前设定的闹钟，函数的返回值仍然是以前设定的闹钟时间还余下的秒数。

2.4 硬件异常产生信号

（1）程序崩溃的本质：
当我们的程序中存在除0、越界或者野指针时引起程序崩溃，其本质就是因为进程收到了来自操作系统的异常信号。那么操作系统为什么知道这些异常的呢？

原因是CPU当中有许多的寄存器，当对两个数进行算术运算时，操作系统先将这两个操作数分别放到两个寄存器当中，然后进行运算并把结果写回寄存器当中。此外，CPU当中还有一组寄存器叫做状态寄存器，它可以用来标记当前指令执行结果的各种状态信息，如有无进位、有无溢出等等。而操作系统是软硬件资源的管理者，在程序运行过程中，若操作系统发现CPU内的某个状态标志位被置位，而这次置位就是因为出现了某种除0错误而导致的，那么此时操作系统就会马上识别到当前是哪个进程导致的该错误，并将所识别到的硬件错误包装成信号发送给目标进程。

①用以下代码模拟野指针异常：

#include <iostream>
#include <signal.h>
using namespace std;

int cnt = 0;

void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << endl;
}

int main()
{
    signal(SIGSEGV, handler);

    sleep(1);

    int* p = nullptr;
    *p = 1000;
    while (true);

    return 0;
}

②运行结果：

硬件异常被硬件以某种方式被硬件检测到并通知内核，然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令，CPU的运算单元会产生异常，内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址，MMU会产生异常，内核将这个异常解释为SIGSEGV信号发送给进程。

3. 阻塞信号

3.1 信号阻塞即其他相关概念

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

3.2 信号在内核中的表示

信号在内核中的表示示意图：

• 在block位图中，比特位的位置代表某一个信号，其内容表示该信号是否被阻塞。
• 在pending位图中，比特位的位置代表某一个信号，其内容表示是否收到该信号。
• handler表本质上是一个函数指针数组，数组的下标代表一个信号，数组的内容表示该信号递达时的处理动作，包括默认、忽略和自定义。
• block、pending和handler这三张表是一 一对应的。

【说明】

1. 每个信号都有两个标志位，分别表示阻塞（Block）和未决（Pending），还有一个函数指针表示对信号的处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。如上图所示。
2. SIGINT信号以及产生，但是正处于阻塞状态，所以暂时不能被递达。虽然它的处理动作是忽略，但是没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除该阻塞。
3. SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。

【注意】
如果在进程解除对某信号的阻塞之前，这种信号产生过多次：POSIX.1允许系统递送该信号一次或多次。但是Linux是这样实现的：常规信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里。

3.3 sigset_t

从信号在内核中的示意图来看，每个信号只有一个比特位的未决标志，非0即1，不记录该信号产生了多少次，阻塞标志也是这样表示的。

因此，未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t的定义如下：

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
	unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

typedef __sigset_t sigset_t;

sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态:

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

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

3.4 信号集操作函数

sigset_t类型对于每种信号用一个比特位表示“有效”或“无效”状态，至于这个类型内部如何存储这些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所指向的信号集，使其中所有信号的对应比特位清零，表示该信号集不包含任何有效信号。

2. 函数sigfillset初始化set所指向的信号集，使其中所有信号的对应比特位置位，表示该信号集的有效信号包括系统支持的所有信号。

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

4. 初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

5. 前面四个函数都是调用成功返回0，出错返回-1。sigismember是一个布尔函数，用于判断一个信号集的有效信号中是否包含某种信号，若包含则返回1，不包含则返回0，出错返回-1。

3.5 sigprocmask

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

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

返回值：调用成功返回0，失败则返回-1。

参数说明：

1. 若oset是非空指针，则读取进程当前信号屏蔽字，并提供oset参数传出；

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

3. 如果oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。

4. 假设当前的信号屏蔽字为mask，下表说明了how参数的可选值及其含义：

可选值	含义
SIG_BLOCK	set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask = mask 按位或 set
SIG_UNBLOCK	set包含了我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask = mask &~ set
SIG_SETMASK	设置当前信号屏蔽字为set所指向的值，相当于mask = set

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

3.6 sigpending

sigpending函数的作用是读取当前进程的未决信号集，通过set参数传出。
【函数原型】

int sigpending(sigset_t *set);

返回值：调用成功返回0，否则返回-1。

（1）利用如上几个函数进行代码演示：

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

using namespace std;

void handler(int signo)
{
    cout << "我是一个进程，获取了" << signo << "信号" << endl;
}

void PrintPending(sigset_t& pending)
{
    for(int signo = 31; signo > 0; signo--)
    {
        if(sigismember(&pending, signo))
        {
            cout << "1";
        }
        else 
        {
            cout << "0";
        }
    }

    cout << endl;
}

int main()
{
    signal(2, handler);
    cout << getpid() << endl;
    // 我可以将所有的信号都进行屏蔽，信号不就不会被处理了吗？ 肯定的！9号信号不会被屏蔽
    sigset_t bset, oset;
    sigemptyset(&bset);
    sigemptyset(&oset);
    for (int i = 1; i <= 31; i++)
    {
        sigaddset(&bset, i); // 屏蔽了所有信号吗？？？
    }

    sigprocmask(SIG_SETMASK, &bset, &oset);

    int cnt = 0;
    sigset_t pending;
    while (1)
    {
        // 获取
        int n = sigpending(&pending);
        if (n < 0)
        {
            continue;
        }

        // 打印
        PrintPending(pending);
        sleep(1);

        cnt++;
        if (cnt == 20)
        {
            cout << "解除对所有信号的block..." << endl;
            sigprocmask(SIG_SETMASK, &oset, nullptr);
        }
    }

    return 0;
}

该程序的功能是先用上述的函数将2号信号进行屏蔽（阻塞），使用kill命令或组合按键向进程发送2号信号。此时2号信号会一直被阻塞，并一直处于pending（未决）状态。使用sigpending函数获取当前进程的pending信号集进行验证。20秒后，解除对2号信号的屏蔽。

（2）执行结果如下：

第一次发送2号信号，我们可以发现signal函数没有收到2号信号，而pending表中存在2号信号，0秒后，解除对2号信号的屏蔽，signal函数就接收到了2号信号。

这里我们可以发现，在解除2号信号之后，2号信号的自定义动作的打印是在打印全为0的pending表之前执行的。这是因为如果调用sigprocmask解除对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达。

4. 信号捕捉

4.1 内核态和用户态

在认识信号捕捉之前，首先得认识内核和用户之间的连续和区别。

用户态和内核态是操作系统的两种运行状态。

• 内核态：处于内核态的 CPU 可以访问任意的数据，包括外围设备，比如网卡、硬盘等，处于内核态的 CPU 可以从一个程序切换到另外一个程序，并且占用 CPU 不会发生抢占情况，一般处于特权级 0 的状态我们称之为内核态。

• 用户态：处于用户态的 CPU 只能受限的访问内存，并且不允许访问外围设备，用户态下的 CPU 不允许独占，也就是说 CPU 能够被其他程序获取。

进程收到信号之后，并不是立即处理信号，而是在从内核态切换回用户态的时候，进行对信号的检查与处理。

操作系统在内核态与用户态之间切换的情况：

1. 从用户态切换为内核态通常有如下几种情况：
   • 进行系统调用时
   • 当前进程的时间片结束，导致进程切换
   • 产生异常、中断、陷阱等
2. 从内核态切换为用户态有如下几种情况：
   • 系统调用返回时
   • 进程切换完毕
   • 异常、中断、陷阱等处理完毕

此外，由用户态切换为内核态我们称之为陷入内核。每当我们需要陷入内核的时，本质上是因为我们需要执行操作系统的代码，比如系统调用函数是由操作系统实现的，我们要进行系统调用就必须先由用户态切换为内核态。

4.2 内核空间和用户空间

我们都知道每一个进程都有属于自己的进程地址空间，该空间其实是有内核空间和用户空间组成的。其中用户实现的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系；而内核空间是只操作系统的代码和数据，通过内核级页表与物理内存之间建立映射关系。

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，由所有进程所共同拥有。只是唯一区别在于该进程是否有权利去访问内核空间。

4.3 内核实现信号捕捉

信号捕捉示意图：

当执行主控制流程的时候，可能因为某些情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。在查看pending位图时，如果发现有未决信号，并且该信号没有被阻塞，那么此时就需要该信号进行处理。如果待处理信号的处理动作是默认或者忽略，则执行该信号的处理动作后清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可。

但如果待处理信号是自定义捕捉的，即该信号的处理动作是由用户提供的，那么处理该信号时就需要先返回用户态执行对应的自定义处理动作，执行完后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，继续执行主控制流程的代码。

4.4 sigaction函数

捕捉信号除了用前面用过的signal函数之外，我们还可以使用sigaction函数对信号进行捕捉。
【函数原型】

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

功能：sigaction函数可以读取和修改与指定信号相关联的处理动作。
返回值：调用成功返回0，出错返回-1。
参数：

• signum代表指定信号的编号。
• 若act指针非空，则根据act修改该信号的处理动作。
• 若oldact指针非空，则通过oldact传出该信号原来的处理动作。

（1）参数act和oldact都是结构体指针变量，该结构体的定义如下

struct sigaction
{
    /* Signal handler.  */
#ifdef __USE_POSIX199309
    union
    {
        /* Used if SA_SIGINFO is not set.  */
        __sighandler_t sa_handler;
        /* Used if SA_SIGINFO is set.  */
        void (*sa_sigaction)(int, siginfo_t *, void *);
    } __sigaction_handler;
#define sa_handler __sigaction_handler.sa_handler
#define sa_sigaction __sigaction_handler.sa_sigaction
#else
    __sighandler_t sa_handler;
#endif

    /* Additional set of signals to be blocked.  */
    __sigset_t sa_mask;

    /* Special flags.  */
    int sa_flags;

    /* Restore handler.  */
    void (*sa_restorer)(void);
};

（2）结构体的第一个成员sa_handler：

• 将sa_handler赋值为常数SIG_IGN传给sigaction函数，表示忽略信号。
• 将sa_handler赋值为常数SIG_DFL传给sigaction函数，表示执行系统默认动作。
• 将sa_handler赋值为一个函数指针，表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数。

注意： 所注册的信号处理函数的返回值为void，参数为int，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。显然这是一个回调函数，不是被main函数调用，而是被系统所调用。

（3）结构体的第二个成员sa_sigaction：

• sa_sigaction是实时信号的处理函数。

（4）结构体的第三个成员sa_mask：

• 如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时，自动恢复原来的信号屏蔽字。

（5）例如，下面我们用sigaction函数对2号信号进行了捕捉，将2号信号的处理动作改为了自定义的打印动作。

#include <iostream>
#include <cstring>
#include <signal.h>
#include <unistd.h>
using namespace std;

void handler(int signo)
{
    cout << "获得一个信号：" << signo << endl;

}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));

    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 1);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);

    act.sa_handler = handler;
    sigaction(2, &act, &oact);

    while(1)
    {
        cout << "main running " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

（6）运行结果：

5. 可重入函数

理解可重入函数，可以通过链表的插入过程来进行理解。

如图，main函数调用insert向链表中插入一个节点node1，但是代表执行的1的位置时，该进程收到了一个信号，该信号的处理动作是再向链表插入一个节点node2，处理完该信号后又返回4的位置继续执行插入node1的动作。现在则发生了下面的情况：

我们可以发现最终node1和node2指向了同一个节点，但是只有node1真正的插入了链表，而node2却丢失了，造成内存泄漏。

在该例中，main函数和sighandler函数使用不同的堆栈空间，它们之间不存在调用与被调用的关系，是两个独立的控制流程，因此insert函数被不同的控制流调用，造成了第一次调用还没有返回时就再次调用了该函数，这种现象称之为可重入现象。

然而insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数我们称之为不可重入函数，反之，如果一个函数只访问自己的局部变量或参数，则称之为可重入（Reentrant）函数。

如果一个函数符合以下条件之一则是不可重入的：

• 调用了malloc或free，因为malloc也是用全局链表来管理堆的。
• 调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

6. 重识 volatile 关键字

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

例如，下面的代码实现了对2号信号的捕捉，当收到2号信号时，将全局变量flag由0变为1，观察程序是否能正常退出。

（1）首先不使用volatile关键字修饰flags：

#include <iostream>
#include <signal.h>
using namespace std;

int flag = 0;

void handler(int signo)
{
    flag = 1;
    cout << "falg被修改" << endl;
}

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

    cout << "进程正常退出" << endl;

    return 0;
}

（2）运行结果：

该程序的运行过程好像都在我们的意料之中，但实际并非如此。代码中的main函数和handler函数是两个独立的执行流，而while循环是在main函数当中的，在编译器编译时只能检测到在main函数中对flag变量的使用。

此时编译器检测到在main函数中并没有对flag变量做修改操作，在编译器优化级别较高的时候，就有可能将flag设置进寄存器里面。

此时main函数在检测flag时只检测寄存器里面的值，而handler执行流只是将内存中flag的值置为1了，那么此时就算进程收到2号信号也不会跳出死循环。

（3）在编译代码时携带-O3选项使得编译器的优化级别最高，此时再运行该代码。

此时再向进程发生2号信号，该进程也不会终止。

（4）若在flag变量前面加上volatile修饰，则进程就可以进程退出了。

7. SIGCHLD信号

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

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

（1）编写一个程序完成以下功能：

①父进程调用fork函数创建出子进程，子进程调用exit(2)终止，父进程自定义SIGCHLD信号的处理函数，在其中调用wait函数获得子进程的退出状态并打印。

#include <iostream>
#include <cstring>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;

void handler(int signo)
{
    pid_t rid;
    while((rid = waitpid(-1, nullptr, WNOHANG)) > 0)
    {
        cout << "I am proccess: " << getpid() << " catch a signo: " << signo << "child process quit: " << rid << endl;
    }

    sleep(5);
}

int main()
{
    signal(17, handler);
    pid_t id = fork();

    if(id == 0)
    {
        while (true)
        {
            cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl;
            sleep(5);
            break;
        }

        cout << "child quit!!!" << endl;
        exit(0);
    }

    while (true)
    {
        cout << "I am father process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

②运行结果：

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

①测试代码如下：

#include <iostream>
#include <cstring>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;

int main()
{
    // signal(SIGCHLD, FreeChld);
    // 子进程退出的时候，默认的信号处理就是忽略吗？
    // 调用signal/sigaction SIG_IGN, 意义在哪里呢？
    // SIG_IGN手动设置，让子进程退出，不要给父进程发送信号了，并且自动释放
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 5; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            //子进程
            int cnt = 3;
            while (cnt)
            {
                cout << "我是子进程, pid: " << getpid() << " 当前的cnt: " << cnt-- << endl;
                sleep(1);
            }

            cout << "子进程退出，进入僵尸状态" << endl;
            exit(0);
        }
        // sleep(1);
    }

    while (true)
    {
        cout << "我是父进程，我正在运行: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

②运行结果：

这样，父进程调用signal将SIGCHLD的处理动作置为SIG_IGN，fork出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程，父进程也可以做自己的工作并且不用管子进程，提高了程序的运行效率。