（一）阻塞信号

1.信号其他相关的概念

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

信号 传递过程：信号产生 -> 信号未决 -> 信号递达

2.在内核中表示

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

block和pending都是用位图表示，而handler是一个函数指针数组

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

3.sigset_t

从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。

因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

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

#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_NWORDS 大小为 32，所以这是一个可以包含 32 个 无符号长整型 的数组，而每个 无符号长整型 大小为 4 字节，即 32 比特，至多可以使用 1024 个比特位

4.信号集操作函数

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

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

• sigemptyset函数：初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号。
• sigfillset函数：初始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号。
• sigaddset函数：在set所指向的信号集中添加某种有效信号。
• sigdelset函数：在set所指向的信号集中删除某种有效信号。
• sigemptyset、sigfillset、sigaddset和sigdelset函数都是成功返回0，出错返回-1。
• sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含
  某种 信号,若包含则返回1,不包含则返回0,出错返回-1。

5.sigprocmask（设置阻塞）

sigprocmask函数可以用于读取或更改进程的信号屏蔽字（阻塞信号集），该函数的函数原型如下：

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

函数说明：

• 参数how：
  
• 参数set：
  就是一个信号集，主要从此信号集中获取屏蔽信号信息
• 参数oldset：
  一个信号集，保存进程中原来的 block 表

返回值：

• sigprocmask函数调用成功返回0，出错返回-1。
• 如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达。

6.sigpending（得到未决状态）

sigpending函数可以用于读取进程的未决信号集，该函数的函数原型如下：

sigpending函数读取当前进程的未决信号集，并通过set参数传出。该函数调用成功返回0，出错返回-1。

（二）捕捉信号

1、内核空间与用户空间

每一个进程都有自己的进程地址空间，该进程地址空间由内核空间和用户空间组成：

• 用户所写的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系。
• 内核空间存储的实际上是操作系统代码和数据，通过内核级页表与物理内存之间建立映射关系。

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，所有进程看到的都是一样的内容。

内核级页表只有一个并且是全部进程共享。而用户级页表有多个，每个进程都有一个独立的用户级页表。

2、内核态与用户态

1. 内核态通常用来执行操作系统的代码，是一种权限非常高的状态。
2. 用户态是一种用来执行普通用户代码的状态，是一种受监管的普通状态。

为什么要区分 用户态 与 内核态 ？

• 内核空间中存储的可是操作系统的代码和数据，权限非常高，绝不允许随便一个进程对其造成影响
• 区域的合理划分也是为了更好的进行管理

2.1 内核如何实现信号的捕捉

• 用户态切换到内核态：

  • 需要进行系统调用时。
  • 当前进程的时间片到了，导致进程切换。
  • 产生异常、中断、陷阱等。

• 内核态切换到用户态：

  • 系统调用返回时。
  • 进程切换完毕。
  • 异常、中断、陷阱等处理完毕。

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

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

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

当识别到信号的处理动作是自定义时，能直接在内核态执行用户空间的代码吗？
理论上是可以实现的，但是是绝对不允许的。
很好理解，倘若可以在内核态执行用户空间的代码，那么会不会有非法操作？假如在内核态有一个非法操作是将其数据库都删掉了，那么这可恢复不了了，因为内核态的权限是足够大的。虽然在用户态时没有足够的权限做到清空数据库，但是如果是在内核态时执行了这种非法代码，那么数据库就真的被清空了，因为内核态是有足够权限清空数据库的。
也就是说，不能让操作系统直接去执行用户的代码，因为操作系统无法保证用户的代码是合法代码，即操作系统不信任任何用户。

3.捕捉信号

signal函数

signal 函数可以用来 修改信号的执行动作，也叫注册自定义执行动作。

函数理解：

• 参数 1：
  待操作信号的编号，为 int，单纯地传递 信号名也是可以的，因为信号名其实就是信号编号的宏定义
• 参数 2：待注册的新方法。
  参数2 是一个函数指针，意味着需要传递一个 参数为 int，返回值为空的函数对象
  我们需要手动创造一个函数对象，就像下面这样：

void handler(int signo)
{cout << "当前 " << signo << " 号信号正在尝试执行相应的动作" << endl;
}

sigaction函数

捕捉信号除了用上面的signal函数之外，我们还可以使用sigaction函数对信号进行捕捉，sigaction函数的函数原型如下：

#include <signal.h>int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);struct sigaction 
{void     (*sa_handler)(int);	//自定义动作void     (*sa_sigaction)(int, siginfo_t *, void *);	//实时信号相关，不用管sigset_t   sa_mask;	//待屏蔽的信号集int        sa_flags;	//一些选项，一般设为 0void     (*sa_restorer)(void);	//实时信号相关，不用管
};

函数说明：

• 参数1：待操作的信号
• 参数2：sigaction 结构体，具体成员如上所示
• 参数3：保存修改前进程的 sigaction 结构体信息
• 返回值：成功返回 0，失败返回 -1 并将错误码设置

再了解sigaction结构体中的 sa_mask 字段。
sa_mask：当信号在执行 用户自定义动作 时，可以将部分信号进行屏蔽，直到 用户自定义动作 执行完成。
也就是说，我们可以提前设置一批 待阻塞 的 屏蔽信号集，当执行 signum 中的 用户自定义动作 时，这些 屏蔽信号集 中的 信号 将会被 屏蔽（避免干扰 用户自定义动作 的执行），直到 用户自定义动作 执行完成。

使用示范：

#include<iostream>
#include <string.h>
#include <unistd.h>
#include <signal.h>
using namespace std;
struct sigaction act, oldact;
void handler(int signo)
{cout << "get a signo#" << signo << endl;sigaction(2, &oldact, NULL);
}
int main()
{memset(&act, 0, sizeof(act));memset(&oldact, 0, sizeof(oldact));act.sa_handler = handler;act.sa_flags = 0;sigemptyset(&act.sa_mask);sigaction(2, &act, &oldact);while(1){cout << "I am a process..." << endl;sleep(1);}return 0;
}

3.可重入函数

可以被重复进入的函数称为 可重入函数

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

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为 不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。

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

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

4.volatile关键字

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

我们看到下面代码：

#include<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
int flag = 0;
void handler(int signo)
{cout << "get a signal is#" << signo << endl;flag = 1;
}
int main()
{signal(2, handler);cout << "process beginning" << endl;while(!flag){// 什么也不做}cout << "process exit..." << endl;return 0;
}

我们将2号信号进行捕捉，当进程收到2号信号后会将全局变量flag由0置1。也就是说，在进程收到2号信号之前，该进程会一直处于死循环状态，直到收到2号信号时将flag置1才能够正常退出。

上面的观点不一定是正确的！！
当我们修改编译器的优先级时，将优化级别设为更高是一样的结果，如果设为 O0 则会符合预期般的运行，说明我们当前的编译器默认的优化级别是 O0。编译器就会对上述代码做出优化！

代码中的main函数和handler函数是两个独立的执行流，而while循环是在main函数当中的，在编译器编译时只能检测到在main函数中对flag变量的使用。此时编译器检测到在main函数中并没有对flag变量做修改操作，在编译器优化级别较高的时候，就有可能将flag的值设置进寄存器里面。此时main函数在检测flag时只检测寄存器里面的值，而handler执行流只是将内存中flag的值置为1了，那么此时就算进程收到2号信号也不会跳出死循环，因为编译器直接从寄存器上拿到值了。

5.SIGCHLD信号

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

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

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/wait.h>
using namespace std;
void handler(int signo)
{cout << "get a signal#" << signo << endl;int ret = 0;while ((ret = waitpid(-1, NULL, WNOHANG)) > 0){cout << "wait child" << ret << "sucess" << endl;}
}
int main()
{signal(SIGCHLD, handler);pid_t id = fork();if (id == 0){//childcout << "child is running, begin dead#" << getpid() << endl;sleep(3);exit(1);}//fatherwhile (1);return 0;
}

SIGCHLD属于普通信号，记录该信号的pending位只有一个，如果在同一时刻有多个子进程同时退出，那么在handler函数当中实际上只清理了一个子进程，因此在使用waitpid函数清理子进程时需要使用while不断进行清理。

1. 信号处理期间的附加规则
   在信号处理函数执行期间，内核会自动将该信号加入信号屏蔽字（临时阻塞）。此时：

   • 若该信号再次触发，会被标记为未决状态（$sigpending$位置1），但需等待当前处理函数结束后才会递送。
   • 对于非实时信号（如SIGINT），多次触发仅保留一次未决记录；**实时信号（如SIGRTMIN+1）**则支持排队，每次触发均独立记录。

2. 关键流程图释

   信号触发 → 检查是否被阻塞 → 是 → 加入sigpending表（置1）↓ 否  立即递送处理
   

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

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
using namespace std;
int main()
{signal(SIGCHLD, SIG_IGN);pid_t id = fork();if (id == 0){//childcout << "child is running, child dead:" << getpid() << endl;sleep(3);exit(1);}//fatherwhile (1);return 0;
}

原理：在设置 SIGCHLD 信号的处理动作为忽略后，父进程的 PCB 中有关僵尸进程处理的标记位会被修改，子进程继承父进程的特性，子进程在退出时，操作系统检测到此标记位发生了改变，会直接把该子进程进行释放