【linux】进程信号

---

1、信号的预备工作

我们这里讲的信号和前一节的信号量没有半毛钱关系

信号讲什么呢？
我们通过一张图来了解

1、[1,31]号信号是不可靠信号，[34,64]是可靠信号
2、可靠信号可以将同类信号记录多次，处理多次，而不可靠信号同类型信号只会记录一次，处理一次（后面会体现出来）

这里我们以红绿灯为样例：

我们能够知道什么是红灯，绿灯，黄灯——认识
红灯停，绿灯行，黄灯等——行为产生
这样才叫做识别红绿灯

如果不管红绿灯是什么灯，都直接过马路，这就表示不能够识别红绿灯

我们继续来学习：

1、人为什么能够识别红绿灯呢？->因为有人教育过你（手段）——让我们大脑中记住了红绿灯对应的属性或者对应行为

2、当信号到来的时候，我们不一定会立马处理这个信号。信号可以随时产生，我们可能做着更重要的事情（异步）
异步举例：

1、你点的外卖到楼下了，外卖小哥给你打电话，你在打游戏没有接
2、老师的快递到了，他让张三去拿，张三去了，老师对其他同学说我们继续上课不等张三了

同步举例：老师的快递到了，他让张三去拿，张三去了，老师对其他同学说我们等张三回来了再上课。再等的期间什么都不做，等张三回来再继续上课

3、信号到来---------时间窗口（必须要记住这个信号）-----------信号被处理
如果记不住，那么信号就丢失了，我们说过信号可以随时产生，那我们不记住信号的话，全部都丢弃就乱套了！

4、我们处理信号大致有3种动作：

1、默认动作（绿灯亮了过马路）
2、自定义动作（绿灯亮了，唱首歌，跳个舞再过马路）
3、忽略动作（绿灯亮了，直接不管，不过马路）

举例：闹钟响了：默认动作——起床；自定义动作——伸个懒腰再其次；忽略动作——继续睡觉

小结

1、信号前[1,31]是普通信号（实时信号我们这里不考虑）
2、当我们没有收到信号的时候，我们就知道当信号到来的时候该怎么去处理——潜台词：我（进程/线程）能够识别信号
3、识别信号：1、进程/线程能够认识该信号；2、进程/线程知道收到信号意味着什么，以及后续的行为是什么
4、当信号的到来进程/线程并不是第一时间去处理，因为信号的产生是异步的，进程/线程可能正在做更重要的工作，所以信号会在合适的时间被处理
5、既然信号会在合适的时间被处理，那么进程/线程一定要能够保存信号，不然信号很容易丢失
6、信号的三个动作：默认，自定义，忽略

那么我们怎么把上面的概念迁移到进程中呢？

共识：信号是给进程发的（kill -9 pid）

1、进程是如何识别信号的呢？ —— 认识+动作
2、进程本身是被程序员编写的属性和逻辑的集合——程序员编码完成（进程是怎么识别信号的，根本原因就是：程序员在进程中内置了进程该如何去处理某个信号的相关问题）
3、当进程收到信号的时候，进程可能正在指向更重要的代码，所以信号不一定会被立即处理
4、进程本身必须要对信号具有保存能力（不然很容易丢失信号，从而导致一系列问题）——保存时间【信号产生之时，到信号处理之时】
5、进程处理信号的时候，一般有3种动作——默认，自定义，忽略【进程处理信号被称为：信号被捕捉】

如果把一个信号发送给进程，而进程要保存信号，那么，应该把信号保存在哪里呢？——进程控制块PCB，也就是task_struct结构体里面（未来创建进程，将task_struct结构体实例化，里面有一个成员可以用来保存信号）！

既然可以保存到task_struct里面，那么该如何保存呢？换句话说，我们怎么知道进程是否收到了指定信号[1,31]呢？（34到64我们不考虑）
答案就是：比特位

我们的task_struct结构体里面有一个32位的成员——signal

到这里，我们如何理解信号的发送呢？

信号发送的本质：修改pcb中的信号位图！——pcb是由os定义维护的内核数据结构对象——pcb的管理着是os，那么谁有权修改pcb里面的内容呢？——os！——未来无论我们学习多少种信号发送方式，本质都是通过os向目标进程发送信号——那么我们想要自己编写代码发送信号，就表示os必须要提供发送信号，处理信号的相关系统调用接口！

所以，我们前面的kill命令底层一定调用了对应的系统调用

到这里，我们信号学习的预备工作就做完了，接下来就行信号的产生了

2、信号的产生

2-1、见见猪跑

ctrl + c ：终止前台进程

我们首先写一个循环代码，然后提供ctrl + c进行终止：

ctrl + c：热键——本质上ctrl + c是一个组合键——被os识别到——os将ctrl + c解释成为2号信号——2) SIGINT——进程对应的pcb里面的信号位图2号位由0置1，信号就发送完毕——进程保存信号之后在合适的时间处理信号（cpu速度非常快，这里的合适时间对电脑来说过一段时间，对我们来说是非常快的）——我们没有对2号信号的动作做处理，所以默认执行2号信号的默认动作

man 7 signal  //查看信号

man 2 signal

这里的handler是我们设置好的回调函数，自动调用

#include <iostream>
#include <unistd.h>  //sleep和getpid需要
#include <signal.h>

using std::cin;
using std::cout;
using std::endl;

void handler(int signo) // 参数是信号编号，函数名可以随便写的
{
    cout << "进程捕捉到了一个信号，信号的编号是：" << signo << endl;//我们把2号信号的默认动作，改成了自定义动作
    //exit(0);//可以杀死进程
}
int main()
{
    signal(2, handler);//这里是signal函数的调用，并不是handler函数的调用
    //仅仅是设置了对2号信号的捕捉方法，并不代表该方法被调用了
    //一般这个方法不会被执行，除非捕捉到了对应的信号！
    while (1)
    {
        cout << "我是一个进程：" << getpid() << endl;
        sleep(1);
    }
    return 0;
}

采用kill -9 pid就可以杀死进程了：

所以，键盘的组合键是发送信号的一种方式！

2-2、信号产生的方式（重点）

2-2-1、通过终端按键产生信号

简单来说就是使用：键盘快捷键

ctrl + c 
ctrl + \

2号和3号信号默认动作——终止进程

默认情况下shell就是bash进程在运行，我们运行自己的代码，就是把我们的进程变成了前台进程，bash变成了后台进程

注意：

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

2-2-2、系统调用向目标进程发送信号

os具有向目标进程发送信号的能力，但是这个能力不是os使用的，而是给用户使用的——有能力是一回事，使用又是一回事
系统调用：由用户发起，由操作系统执行

2-2-2-1、kill函数

	kill函数——可以向任意进程发送任意信号

我们前面使用的kill命令底层就是调用kill函数

代码测试：
makefile：

.PHONY:all
all:mysignal mytest

mysignal:mysignal.cpp
	g++ -o $@ $^ -std=c++11
mytest:mytest.cc
	g++ -o mytest mytest.cc -std=c++11
.PHONY:
clean:
	rm -rf mysignal mytest

mytest.cc：

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>

using std::cin;
using std::cout;
using std::endl;



int main()
{
    
    while (1)
    {
        cout << "我是一个进程：" << getpid() << endl;
        sleep(1);
    }
    return 0;
}

mysignal.cc：

#include <iostream>
#include <unistd.h>    //sleep和getpid需要
#include <sys/types.h> //系统调用需要
#include <signal.h>
#include <string>
#include <cstdio>
#include <cstring>

using std::cin;
using std::cout;
using std::endl;

static void Usag(const std::string &proc) // 使用该进程的手册
{
    cout << "\nUsag : " << proc << "pid signo\n"
         << endl;
}
int main(int argc, char *argv[]) // 使用规则 ： ./myprocess pid signo（字符串）
{
    if (argc != 3) // 如果argc不等于3，也就是使用规则错误
    {
        Usag(argv[0]);
        exit(1);
    }
    pid_t pid = atoi(argv[1]); //   ./myprocess pid signo都是以字符串的形式传进来的
    int signo = atoi(argv[2]); //  我们需要转成对应的类型

    int n = kill(pid, signo);
    if (n != 0)
    {
        std::cerr << "errno" << strerror(n) << endl;
        perror("kill"); // 出错打印
    }
    return 0;
}

2-2-2-2、raise函数

raise函数——给自己（本进程）发送任意信号——任意信号！！！

kill（getpid(),signo）——模拟实现raise函数

2-2-2-3、abort函数

abort函数——给自己（本进程）发送指定的信号——SIGABRT（6号信号）

    while (count <= 7)
    {
        printf("%d\n", count++); // 这里c打印比c++代码简单
        sleep(1);
        if (count > 3)
            //raise(3);
            abort();
    }

kill(getpid(),SIGABRT)——模拟实现abort函数

2-2-2-4、小结

关于信号处理行为的理解：很多情况下，进程收到的绝大部分信号，默认处理动作都是终止进程

信号的意义：信号的不同，代表这不同的事件。但是对事件发生之后的处理动作可以一样！

2-2-3、硬件异常产生信号

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

为什么除0就会终止进程呢？——答案（这个答案是我告诉大家的！）：进程收到了来自os的信号！——SIGFPE（8号信号）

我们怎么证明除0进程os发送的是8号信号呢？
可以通过上一节的signal进行喜欢捕捉！

void handler(int signo)自定义动作，执行handler函数的时候，进程会循环打印
{
    cout << "进程捕捉到了一个信号，信号的编号是：" << signo << endl;//捕捉到8号信号，默认动作不会执行了！
    sleep(1);
}
int main()
{
    signal(SIGFPE, handler);//如果一切正常，那么handler方法不会被调用，当触发了除0错误，收到了SIGFPE8号信号，就自动调用
    while (1)
    {
        int a = 10;
        a /= 0;
    }
    return 0;
}

两个问题：

2-2-3-1、如何理解除0

os怎么知道进程除0了，然后os经过解释给进程发送8号信号呢？——os怎么知道进程内部发送了除0操作
这个问题1就牵扯到我们的硬件知识了！

当溢出标记位被置为1的时候，就表示该次计算的结果没有意义，不会被采纳！——10/0可以被计算，但是结果不对，所以需要溢出标记位来判断结果

我们来总结一下流程：
运行进程A，执行我们的代码——将10/0经过汇编等一系列操作拿到cpu的寄存器上面——cpu计算不出正确结果，得到一个无穷大的数，结果溢出，将状态寄存器由0置1——此时cpu发生了运算异常，告知给os——os通过cpu内部的状态寄存器发现了运算异常——os找到进程A，然后修改进程A的PCB进程控制块里面的信号位图，从而达到os向进程A发送信号的目的——然后进程A再执行后续工作（默认就是结束进程）

2-2-3-2、为什么循环打印结果

为什么我们只捕捉了一次8号信号，但是打印结果会一直死循环打印呢？

1、循环打印结果，说明了进程收到了信号不一定需要退出！——如果进程没有退出，有没有可能进程再次被调度？——cpu内部的寄存器只有一份，但是寄存器的内容，是属于进程上下文的
2、所以，当cpu内部发送问题/异常的时候，我们是没有能力修正过来的，因为cpu内部资源归cpu来进行管理
3、因为进程没有退出，那么当进程被切换的时候（发送轮询），就有了无数次状态寄存器被保存和被恢复的过程（10/0的进程通过时间片会一直从寄存器中拿下来资源保存，以及将资源放回到寄存器）
4、所以，每一次将进程恢复，上下文被拿到寄存器，cpu的状态寄存器就都会发生变化，而os识别到了cpu内部状态寄存器是1

所以，上面的进程会一直打印结果，死循环

2-2-3-3、野指针问题

int *p = nullptr;
p = nullptr;//p的类型是int *类型，所以p可以被赋值为0
*p = 100;//*p对p进行解引用，解引用p拿到0地址处，0地址处是不允许我们做修改，赋值的！

那么为什么野指针就会引发进程崩溃呢？

原因就是进程收到了信号！！！

所以os会给野指针进程发送11号信号——11号信号默认动作终止进程——意义就是：非法的内存使用

那么os怎么知道我这个进程发生了野指针问题呢？

简单来说：除0导致硬件cpu中的状态寄存器由0变1被os知道，发送8号信号；野指针导致cpu中的mmu异常报错被os知道，发送11号信号

C/C++中，发生异常，我们只能捕获一下，打一下日志，其他的问题根本不能直接处理。而要抛异常和捕获异常的原因是：
方便我们快速找到哪一个地方出了问题，节约时间
信号的意义：信号的不同，代表这不同的事件。但是对事件发生之后的处理动作可以一样！——快速知道进程发生了段错误（野指针），计算结果溢出（除0错误）等等，节约了时间

2-2-4、软件条件产生信号

与硬件无关，管道的读端关闭，触发了软件条件，导致进程终止

而我们今天要讲的软件条件产生信号的样例是——定时器软件条件

linux中有一个

	alarm函数——设定闹钟
	调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号（14号信号）, 该信号的默认处理动作是终止当前进程。

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

如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数

int main()
{
    alarm(1);//统计计算机，1s能将数据累加多少次
    int cnt = 0;
    while (1)
    {
        cout << "cnt:" << cnt++ << endl;
    }
    return 0;
}

1s才累加几w次这对于计算机来说太少了，我们试着优化一下，比如去掉每次打印到显示器的io操作

优化代码：

int cnt = 0; // 定义为全局的

void handler(int signo)
{
    cout << "进程捕捉到了一个信号，信号的编号是：" <<  cnt << endl;
    exit(1);
}

int main()
{
    alarm(1);                 // 统计计算机，1s能将数据累加多少次
    signal(SIGALRM, handler); // 如果一切正常，那么handler方法不会被调用，当触发了除0错误，收到了SIGFPE8号信号，就自动调用

    while (1)
    {
        cnt++;
    }
    return 0;
}

输出到外设（显示器打印），大量时间在做IO过程，所以效率低下【云服务器要经过网络，速度会更慢，效率更低下】——IO很慢

小问题：

为什么设置闹钟就是软件条件呢？

其实，”闹钟“就是由软件实现的

我们可以建立一个最小堆，通过when的值来进行排列，when最小值的对象放到堆顶，其他when值大的对象的依次排序放到堆下面，只要链表中第一个对象的时间没有超时，那么堆下面的其他对象也都不会超时

小结：

所以可以看出，闹钟其实是由数据结构等软件构成的，而我们的软件条件产生信号就是——超时（闹钟是否超时）

2-3、总结

1、上面所说的所有信号产生，最终都要有OS来进行执行，为什么？ —— OS是进程的管理者
2、信号的处理是否是立即处理的？ —— 在合适的时候
3、信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？—— 是的，记录在pcb中（信号位图）
4、一个进程在没有收到信号的时候，能否能知道，自己应该对合法信号作何处理呢？ —— 能，因为不同信号的到来要进行的不同处理工作，是默认由程序员来完成的！
5、如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？ —— 上面有，这里就不重复了（简单来说就是os修改目标进程pcb里面的信号位图，由0置1）

2-4、核心转储

接下来我们就来研究一下进程退出时的核心转储问题

在云服务器上面，如果进程是core默认退出的，那么我们看不到明显的现象

ulimit -a : 查看系统各种资源的上限

下面的图片我们可以看到云服务器关闭了core file选项

这里面core dumped加上core文件（core文件后面的id就是引起core问题的进程的pid）就是所谓的核心转储
核心转储：当进程出现异常的时候，我们要将进程在对应的时刻，在内存中的有效数据转储到磁盘中（进程崩溃的上下文）——这就叫核心转储！

说人话就是：如果我们进程终止的信号是core类型的，并且打开了core file选项，那么进程在终止的时候会将二进制有效数据保存在磁盘当中

od + 文件名 将文件内容转换成为8进制

我们为什么要有核心转储这个功能呢？
因为当进程崩溃的时候，我们想要知道的是进程为什么崩溃了，在哪里崩溃的？
所以我们将进程崩溃时候的上下文保存在磁盘当中，支持调试！

那么是如何支持调试的呢？

gdb上下文中 —— core-file  文件名

是Term！！！图片中打错了

2-5、捕捉[1,31]号信号

void handler(int signo)
{
    cout << "进程捕捉到了一个信号，信号的编号是：" << signo << endl;
}

int main()
{
    for (size_t i = 0; i < 32; ++i)
    {
        signal(i, handler);
    }
    while (1)
    {
        cout << "你好！我是..." << getpid() << endl;
        sleep(1);
    }
    return 0;
}

这个kill -9就是管理员信号，就是我们捕捉了os也会认为捕捉无效，因为我们要用这个管理员信号杀死异常的进程，防止异常进程引发一系列问题

到这里我们信号的产生就全部讲完了，下面就进入信号是如何保存的！

3、信号的保存

3-1、阻塞信号

3-1-1、信号其他相关常见概念（要理解并且记住）

1、实际执行信号的处理动作称为信号递达(Delivery)
2、信号从产生到递达之间的状态,称为信号未决(Pending)。
3、进程可以选择阻塞 (Block )某个信号(就算没有信号的到来，进程也可以阻塞信号)。
4、被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
5、注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

我们来一个个细说：

信号在产生之后，经过进程的保存，再到进程处理信号之前 —— 这个过程就叫做信号未决

3-1-2、在内核中的表示（重点）

我们要保存信号及其周边信息，有3种数据结构与保存信号是强相关的！注意：我们所接触到的位图并不仅仅只是一个32位/16位整数，位图：是由一个结构体或者一个结构体里面套一个大数组来实现的，不同的平台实现位图结构存在差异，所以我们下面学习不能直接按位与&，按位或|，按位异或^等操作对位图进行操作，而是要通过os提供的接口来对位图进行操作我们用一个32位整数来表示位图是为了方便我们学习位图！

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

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

pending结构的本质：就是一个位图结构（像一个表格一样，我们称之为penging表）。我们前面学到的os发送信号是通过修改进程对应的pcb中的信号位图来实现发送信号的，而这里的pending表就是我们所说的pcb中的信号位图。而处于pending表中的信号都是未决状态！

而除了pending和block表以外，还有一个handler表！

handler表的本质是一个：函数指针数组（数组）

	typedef void (*handler_t) (int signo);//函数指针handler_t指向一个返回值为void，参数是int类型的函数
	handler_t handler[32]={0};//handler是一个函数指针数组，里面存放的是函数指针类型

而这个handler数组就是我们当前进程捕捉所有信号的方法（只是普通信号）

当我们把handler数组里面的每一个信号处理方法准备好之后，以3号信号为例
os通过修改进程的pending位图，将3号信号位置由0置1，如果进程的block表中3号信号没有被置1，那么进程就通过pending位图中信号的位置，反向拿到信号的编号（1到31），然后进程通过信号的编号，在handler数组里面找到对应的位置（信号的编号对应的就是handler数组的下标!），最后通过数组下标拿到里面的函数指针，最后去执行该函数！

结论：

1、如果一个信号没有产生，并不妨碍该信号可以被先阻塞（两个位图pending和block）
2、进程为什么能够识别信号呢？—— 因为每一个对应的进程的pcb中都有pending，block和handler这3个结构，通过这3个结构，进程不仅可以识别每一个信号，而且还具有每一个信号的后续操作，这就达到了认识+动作的过程，所以进程就能够识别信号了！

如果我们一个进程收到了多个相同的信号，并且信号没有被递达（也就是被处理），那么进程会将后面的信号都丢弃掉，只留下一个，这是进程对普通信号的做法。而对于实时信号，进程对于多个相同的实时信号就不会丢弃，而是采用信号节点的方法一个个将信号像链表一样链接起来（我们这里就不多讲了，实时信号不考虑）

4、信号的处理

4-1、捕捉信号（重要）

4-1-1、知识点1

我们之前学到了：进程收到信号的时候，并不会被立刻递达（处理），而是进程在合适的时候处理，这个合适的时候就是：从内核态返回用户态的时候处理（身份/状态的转换）

用户态：我们自己编写的，没有系统调用的代码
内核态：当我们访问内核的某些硬件或者某些数据时，只能由操作系统来完成（内核数据结构，和相关软硬件资源…），这些资源都是由os管理起来的，只有os能够直接去读取和管理这些资源。所以，用户态想去拿到对应的数据就不行！os看到是用户态就直接拦截了用户态代码拿到数据的操作，只有将身份切换到内核态才能完成拿到数据的操作！

语言方面访问内核数据结构（比如：获取进程pid，进程等待（getpid，waitped等等）），访问硬件资源（访问文件，访问网络，打印到显示器…都是系统调用！），进程切换也是系统调用

stl里面，容器自动扩容的时候，会扩容一段大的空间，并且把这段空间的工作放到用户层，这就是减少进程身份的切换，提高效率
然后就是进程池（后面的线程池），我们先创建好一批进程/线程，需求任务的时候直接分配进程/线程执行就行，避免了频繁调用系统调用创建进程/线程

所以，现在大多数都是：空间换时间，而不是时间换空间！

4-1-2、知识点2

我们怎么知道进程当前是用户态还是内核态的呢？

我们前面学到过，进程执行时，执行的每一段代码的当前的上下文结构要保存在cpu的寄存器当中！cpu内部也要给我们提供一些硬件接口，让我们通过读写寄存器等方式，来设置或者获取cpu的执行级别。一旦cpu的执行级别被设置了，当任何进程在cpu上跑的时候，他要么就是用户态，要么就是内核态了

在cpu内部就完成了虚拟地址（进程地址空间）到物理地址的映射！！！

4-1-3、知识点3

用户态切换到内核态的具体操作：调用系统调用接口（每一个系统调用接口的开始，都有对应汇编指令（比如说int 80：int就是陷入的意思），这些汇编指令让进程在cpu中的CR3寄存器内部的比特位由3变0，也就是让进程由用户态变成了内核态）

我是一个进程，我怎么跑到了os中执行方法（系统调用）了呢？

.当从内核空间跳回到代码区，进程的身份状态也从0内核态，变成了3用户态，然后执行下面的代码！

1、我们进程平时调用系统调用接口，一定是在本进程的上下文去掉的
2、当进程在内部上下文调用某些函数时，进程可以调用一些os正在调度的代码，也就是说进程不一定执行的是程序员写的代码，有可能是os看到进程时间片到了，然后os以进程的进程地址空间为载体，跑一些os内部的其他代码
3、进程/线程不管怎么切换，地址空间的【1，3】G不一样，但是【3，4】G的内容完全一样，所以os能通过任何一个进程/线程或者执行流找到自己
4、我们凭什么能跳到内核空间去执行代码呢？—— 身份切换到内核态就行 —— 我们凭什么能够切换到内核态身份呢？—— 系统调用接口的开始有汇编指令（比如说：int 80等等汇编），帮助我们陷入内核了！

4-1-4、知识点4（重点）

我们上面知道了：进程收到信号的时候，并不会被立刻递达（处理），而是进程在合适的时候处理，这个合适的时候就是：从内核态返回用户态的时候处理（身份/状态的转换），那么也就是说，我在处理信号之前就已经是内核态的身份了！因为只有内核态才能够进行切回用户态，然后才能处理信号（信号递达）

那么，我们的进程怎么才能从用户态切换到内核态呢？

最常见的操作：
1、系统调用
2、进程切换(进程没有执行完，被放到就绪/等待队列里面，而这个工作进程身份自然也要变成内核态，以os身份才能执行)
3、异常、陷阱、缺陷…

我们能用用户态的身份执行内核态的代码？—— 答案肯定是不行的！由于身份状态不够，所以os会自动拦截！
那么，我们能不能用内核态的身份执行用户态的代码？—— 答案是也是不行的！os不相信任何人！os是没有办法知道我们用户态代码有什么操作的，万一我们用户态代码有违规操作（rm -rf /），就产生了严重的后果！
这样一来，就算handler方法出错了：1、影响有限；2、可追溯，谁出问题我找谁

补充 (重点) ： 信号是自定义动作处理的时候，进程是先将pending位图里面信号位置由1置0，然后再切换用户态去执行自定义动作！！！
执行完自定义方法不能直接返回到代码区：
1、我们进行系统调用是从用户态身份转变成内核态身份的，所以最终需要内核态身份转变从用户态身份，进行相对，这样才是一个完整的流程
2、用户态是不能从一个地方跳转到另外一个地方的！必须要由os参与，因为在系统调用的时候，进程的上下文是由os进行保存的。所以不能以用户态跳回代码区

接下来，我们用一张简单的表格来重复上面进程的一系列过程：

4-2、sigset_t

从3-1-2来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。下一节将详细介绍信号集的各种操作。 阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略

pending信号集
block信号集 —— 又称为：信号屏蔽字

4-3、信号集操作函数

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

#include <signal.h>
int sigemptyset(sigset_t *set);//信号全部清0
int sigfillset(sigset_t *set);//信号全部置1
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所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号。
2、函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系统支持的所有信号。
3、注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

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

4-3-1、sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集) —— 哪一个进程调用了sigprocmask函数，就修改该进程的block表！

#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参数的可选值

SIG_BLOCK：添加信号屏蔽字，屏蔽更多的信号
SIG_UNBLOCK：删除信号屏蔽字，取消屏蔽的信号
SIG_SETMASK：重置信号屏蔽字

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

4-3-2、sigpending

sigpending：哪一个进程掉用sigpending函数，就获取该进程的pending位图

#include <signal.h>
sigpending
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。 下面用刚学的几个函数做个实验。程序如下:

程序运行时,每秒钟把各信号的未决状态打印一遍,由于我们阻塞了SIGINT信号,按Ctrl-C将会 使SIGINT信号处于未决状态,按Ctrl-\仍然可以终止程序,因为SIGQUIT信号没有阻塞

4-3-3、实验

1、默认情况下：我们所有的信号都是不被阻塞的
2、默认情况下：如果一个信号被阻塞了，那么该信号不会被递达，也就是不会被处理

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using std::cout;
using std::endl;

#define block_signal 2

static void printf_pending(const sigset_t &pending) // 不想暴露给外部，加上static
{
    for (size_t signo = 31; signo > 0; --signo) // 拿到全部普通信号(打印是反着打印的，所以我们这里信号也要反正来，才保证最终结果顺序是正确的)
    {
        // 判断普通信号在不在pending信号集中
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

int main()
{
    1、屏蔽指定信号
    sigset_t pending, block, oblock;
    // 1、1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);

    // 1、2 添加要屏蔽的信号
    sigaddset(&block, block_signal);
    // 1、3 开始屏蔽,设置信号进内核（进程pcb的block位图）
    sigprocmask(SIG_SETMASK, &block, &oblock); // 将信号屏蔽字替换为block的，而oblock就存放原来的信号屏蔽字

     2、遍历打印pending信号集
    while (1)
    {
        1、初始化 —— 清空pending位图，保证pending位图是全0
        sigemptyset(&pending);
        2、获取pending位图，不初始化也可以，因为这里是覆盖式的获取
        sigpending(&pending);
        3、打印pending位图
        printf_pending(pending);
        sleep(1);
    }
    return 0;
}

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

using std::cout;
using std::endl;

// #define block_signal 2
static std::vector<int> sigarr = {2, 3};

static void printf_pending(const sigset_t &pending) // 不想暴露给外部，加上static
{
    for (size_t signo = 31; signo > 0; --signo) // 拿到全部普通信号(打印是反着打印的，所以我们这里信号也要反正来，才保证最终结果顺序是正确的)
    {
        // 判断普通信号在不在pending信号集中
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

int main()
{
    1、屏蔽指定信号
    sigset_t pending, block, oblock;
    // 1、1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);

    // 1、2 添加要屏蔽的信号
    for (const auto &signo : sigarr)
        sigaddset(&block, signo);
    // 1、3 开始屏蔽,设置信号进内核（进程pcb的block位图）
    sigprocmask(SIG_SETMASK, &block, &oblock); // 将信号屏蔽字替换为block的，而oblock就存放原来的信号屏蔽字

     2、遍历打印pending信号集
    while (1)
    {
        1、初始化 —— 清空pending位图，保证pending位图是全0
        sigemptyset(&pending);
        2、获取pending位图，不初始化也可以，因为这里是覆盖式的获取
        sigpending(&pending);
        3、打印pending位图
        printf_pending(pending);
        sleep(1);
    }
    return 0;
}

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

using std::cout;
using std::endl;

// #define block_signal 2
static std::vector<int> sigarr = {2};

// static std::vector<int> sigarr = {2, 3};

static void printf_pending(const sigset_t &pending) // 不想暴露给外部，加上static
{
    for (size_t signo = 31; signo > 0; --signo) // 拿到全部普通信号(打印是反着打印的，所以我们这里信号也要反正来，才保证最终结果顺序是正确的)
    {
        // 判断普通信号在不在pending信号集中
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

int main()
{
    1、屏蔽指定信号
    sigset_t pending, block, oblock;
    // 1、1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);

    // 1、2 添加要屏蔽的信号
    for (const auto &signo : sigarr)
        sigaddset(&block, signo);
    // 1、3 开始屏蔽,设置信号进内核（进程pcb的block位图）
    sigprocmask(SIG_SETMASK, &block, &oblock); // 将信号屏蔽字替换为block的，而oblock就存放原来的信号屏蔽字

     2、遍历打印pending信号集
    int count = 10;
    while (1)
    {
        1、初始化 —— 清空pending位图，保证pending位图是全0
        sigemptyset(&pending);
        2、获取pending位图，不初始化也可以，因为这里是覆盖式的获取
        sigpending(&pending);
        3、打印pending位图
        printf_pending(pending);
        sleep(1);
        if (count-- == 0)
        {
            cout << "恢复信号屏蔽字" << endl;
            sigprocmask(SIG_SETMASK, &oblock, &block); // 这里oblock就是修改block位图之前的位图
            cout << "恢复信号屏蔽字" << endl;
        }
    }
    return 0;
}

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

using std::cout;
using std::endl;

// #define block_signal 2
static std::vector<int> sigarr = {2};

// static std::vector<int> sigarr = {2, 3};

static void printf_pending(const sigset_t &pending) // 不想暴露给外部，加上static
{
    for (size_t signo = 31; signo > 0; --signo) // 拿到全部普通信号(打印是反着打印的，所以我们这里信号也要反正来，才保证最终结果顺序是正确的)
    {
        // 判断普通信号在不在pending信号集中
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

int main()
{
    1、屏蔽指定信号
    sigset_t pending, block, oblock;
    // 1、1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);

    // 1、2 添加要屏蔽的信号
    for (const auto &signo : sigarr)
        sigaddset(&block, signo);
    // 1、3 开始屏蔽,设置信号进内核（进程pcb的block位图）
    sigprocmask(SIG_SETMASK, &block, &oblock); // 将信号屏蔽字替换为block的，而oblock就存放原来的信号屏蔽字

     2、遍历打印pending信号集
    int count = 10;
    while (1)
    {
        1、初始化 —— 清空pending位图，保证pending位图是全0
        sigemptyset(&pending);
        2、获取pending位图，不初始化也可以，因为这里是覆盖式的获取
        sigpending(&pending);
        3、打印pending位图
        printf_pending(pending);
        sleep(1);
        if (count-- == 0)
        {
            cout << "恢复信号屏蔽字" << endl;
            sigprocmask(SIG_SETMASK, &oblock, &block); // 这里oblock就是修改block位图之前的位图
            cout << "恢复信号屏蔽字" << endl;
        }
    }
    return 0;
}

如果我们非要看到2号信号被捕捉，然后被恢复的过程 —— pending位图2号信号由0置1，再由1置0的完整过程呢？

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

using std::cout;
using std::endl;

// #define block_signal 2
static std::vector<int> sigarr = {2};

// static std::vector<int> sigarr = {2, 3};

static void printf_pending(const sigset_t &pending) // 不想暴露给外部，加上static
{
    for (size_t signo = 31; signo > 0; --signo) // 拿到全部普通信号(打印是反着打印的，所以我们这里信号也要反正来，才保证最终结果顺序是正确的)
    {
        // 判断普通信号在不在pending信号集中
        if (sigismember(&pending, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

static void handler(const int signo)
{
    cout << signo << "信号被递达！" << endl;
}

int main()
{
    捕捉信号
    for (const auto &signo : sigarr)
        signal(signo, handler);
    1、屏蔽指定信号
    sigset_t pending, block, oblock;
    // 1、1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);

    // 1、2 添加要屏蔽的信号
    for (const auto &signo : sigarr)
        sigaddset(&block, signo);
    // 1、3 开始屏蔽,设置信号进内核（进程pcb的block位图）
    sigprocmask(SIG_SETMASK, &block, &oblock); // 将信号屏蔽字替换为block的，而oblock就存放原来的信号屏蔽字

     2、遍历打印pending信号集
    int count = 10;
    while (1)
    {
        1、初始化 —— 清空pending位图，保证pending位图是全0
        sigemptyset(&pending);
        2、获取pending位图，不初始化也可以，因为这里是覆盖式的获取
        sigpending(&pending);
        3、打印pending位图
        printf_pending(pending);
        sleep(1);
        if (count-- == 0)
        {
            cout << "恢复信号屏蔽字" << endl;
            sigprocmask(SIG_SETMASK, &oblock, &block); // 这里oblock就是修改block位图之前的位图
            cout << "恢复信号屏蔽字" << endl;
        }
    }
    return 0;
}

4-4、捕捉信号

4-4-1、内核如何实现信号的捕捉

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

4-4-2、sigaction

捕捉信号的方法：
1、signal
2、sigaction

我们前面学了signal，就下来看看其他的方法：

sigaction和signal的作用一模一样的 —— 对特定信号设置对应的回调方法（对特定信号捕捉，然后信号递达）

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);//参数有结构体，而结构体名称和函数名称是一样的！

第一个参数int signo：是我们要捕捉哪一个指定信号

第二个参数const struct sigaction *act：

下面我们会来谈这个sigset_t sa_mask

第三个参数struct sigaction *oact：对指定信号处理的老的方法

见见猪跑：

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

using std::cout;
using std::endl;

void handler(int signo)
{
    cout << "try a signo : " << signo << endl;
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);//这里sigset_t sa_mask我们还没讲是什么，直接讲它清0处理
    sigaction(SIGINT, &act, &oact);

    while (1)
    {
        sleep(1);
    }

    return 0;
}

好像sigaction和signal没什么区别，我们继续实验：

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

using std::cout;
using std::endl;

void Count(int count)
{
    while (count)
    {
        printf("count : %2d\r", count);
        fflush(stdout);
        --count;
        sleep(1);
    }
    cout << endl;
}
void handler(int signo)
{
    cout << "try a signo : " << signo << endl;
    Count(20);
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGINT, &act, &oact);

    while (1)
    {
        sleep(1);
    }

    return 0;
}

4-4-3、结论（重点）

当我们递达某一个信号的时候，该同类型信号无法被递达！ —— 当前信号正在被捕捉时，系统会自动将当前信号加入到信号屏蔽字中（block位图） —— 当信号完成递达（完成自定义动作）时，系统又会自动接触对该信号的屏蔽（信号屏蔽字移除该信号）

图中的文字描述有一些小问题，下面的表格是完全无错误的！
一般一个信号被解除屏蔽的时候，系统又会自动进行递达当前屏蔽信号，如果该信号已经被pending的话，就再次捕捉（递达/处理）该信号。没有的话就不做任何动作

处理信号过程	pending位图	block位图	说明
当来了一批2号信号的时候	pending位图：…0010	block位图 ： …0000	进程只能收到一个2号信号，因为进程对于普通信号来说，如果我们一个进程收到了多个相同的信号，并且信号没有被递达（也就是被处理），那么进程会将后面的信号都丢弃掉，只留下一个
进程准备进行2号信号递达的时候	pending位图：…0000	block位图 ： …0000	准备进行递达信号，进程会以内核态的身份先将信号在pending位图中位置的值由1置0，然后切回用户态身份执行自定义动作
2号信号递达的时候	pending位图：…0000	block位图 ： …0010	进程开始进行2号信号递达的时候，系统会自动将2号信号添加到信号屏蔽字中（block位图），当2号信号递达完之后，又会自动解除对2号信号的屏蔽，并且自动进行递达当前屏蔽信号——该信号被pending的话，就再次进行2号信号递达，没有pending就不做任何动作
2号信号递达的时候，又来了一批2号信号	pending位图：…0010	block位图 ： …0010	这个时候虽然来了一批2号信号，但只能保存一个2号信号，其他的2号信号都被进程丢弃了（原理同上：来了多个信号，并且因为该信号在信号屏蔽字中，所以该信号无法被递达，那么其他的同类型信号就都被丢弃了！）。此时pending将2号信号位置的值由0置1之后，这个2号信号因为在信号屏蔽字里面，所以不会被递达，而是要等到上一个2号信号递达完成之后，系统解除2号信号的屏蔽，自动递达当前屏蔽信号（也就是2号信号），而且如果pending位图中，2号信号的位置如果是0就不再递达了（表示没有收到2号信号），如果是1再次对2号信号递达（我们这里的pending位图中，此时2号信号的位置的值是1，所以再进行一次2号信号递达！）

所以，如果我们只发了一次2号信号，就不会打印两次结果了！
因为系统解除2号信号屏蔽之后，自动将当前屏蔽信号递达，但是由于只发了一次2号信号，所以2号信号递达的时候，pending位图是全0的，所以系统解除2号信号屏蔽之后，自动将当前屏蔽信号递达的过程就不会发生了

我们进程处理信号原则是：串行处理同类型信号，不允许递归（信号递达的时候，系统自动将该信号添加到信号屏蔽字中）

4-4-4、sigaction中的sigset_t sa_mask

sigset_t  sa_mask ： 当我们正在处理某一种信号的时候，我们也想随便屏蔽其他信号，就可以添加到sa_mask中

还是用上面的样例来说明：

我们对2号信号进行捕捉，进行信号递达，又想把3号信号给屏蔽掉 —— （2号信号执行自定义动作，3号信号被屏蔽无法递达）

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

using std::cout;
using std::endl;

void Count(int count)
{
    while (count)
    {
        printf("count : %2d\r", count);
        fflush(stdout);
        --count;
        sleep(1);
    }
    cout << endl;
}
void handler(int signo)
{
    cout << "try a signo : " << signo << endl;
    Count(20);
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,3);//将3号信号添加到act.sa_mask就完成屏蔽3号信号了
    sigaction(SIGINT, &act, &oact);

    while (1)
    {
        sleep(1);
    }

    return 0;
}

当我们递达2号信号的时候，2号信号和3号信号都进入了信号屏蔽字，都被屏蔽了。2号信号递达完之后，2，3号信号都解除屏蔽，并且pending位图里面什么信号

sigaction函数小结：

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非 空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:

将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函 数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。 如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项,本章的代码都把sa_flags设为0,sa_sigaction是实时信号的处理函数,本章不详细解释这两个字段,有兴趣的同学可以在了解一下

5、可重入函数

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

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

我们可以发现 ： 我们上面的代码是没有错误的，但是最后节点丢失导致内存泄漏了

1、一般而言，我们认为：main执行流和捕捉函数执行流是两个执行流！
2、如果在main和handler中，该函数（insert）被重复进入，并且出了问题 —— 该函数（insert）就是 ：不可重入函数
3、如果在main和handler中，该函数（insert）被重复进入，并且没有出问题 —— 该函数（insert）就是 ：可重入函数

我们能够解决这个不可重入问题吗？ —— 不行！因为不可重入不是一个问题！而是一种特性（不可重入是一个中性词） —— 既然是特性那么我们何谈解决呢？ —— 我们目前大部分情况使用的接口，全都是不可重入的！

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

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

6、volatile

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

我们用C语言代码来进行测试：

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

int quit = 0;

void handler(int signo)
{
    printf("%d号信号正在被捕捉!",signo);
    printf("quit : %d", quit);
    quit = 1;
    printf(" -> %d\n", quit);
}
int main()
{
    signal(2, handler);
    while (!quit)
        ;
    printf("我是正常退出的！\n");
    return 0;
}

我们经常听别人说，编译器会对代码进行优化（前面C++有很多地方），那么我们上面的代码编译器有没有进行优化呢？
答案是有的，只是编译器优化不明显罢了！

但是，我们前面刚刚学了main和信号捕捉是两个执行流！ 默认情况下编译器优化（编译器优化等级低的时候），cpu取到quit，然后进行判断为真为假，如果为假，结果while的！就继续向后运行

编译器优化：只会读取cpu内部的临时数据，不会读取内存的实时数据！

底层的汇编本来是多次mov的，但是编译器优化，只会执行一次mov，然后就不在mov了，只会从cpu寄存器拿数据了！
所以，这里quit一直为0，然后！quit就一直为真，陷入死循环，不会退出！编译器优化：只会读取cpu内部的临时数据，不会读取内存的实时数据！因为寄存器的存在，遮盖住了我们物理内存的数据存在的事实

补充volatile知识点：volatile可以通过加内存屏障，从而实现禁止指令重排优化的问题，从而避免多线程环境下面程序出现排序执行的现象 —— 保证有序性！
像下一节的锁一样，volatile就像一个轻量级锁，通过加内存屏障和取消内存屏障来保证线程/进程的有序性！

7、SIGCHLD信号

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

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

请编写一个程序完成以下功能:父进程fork出子进程,子进程调用exit(2)终止,父进程自定 义SIGCHLD信号的处理函数,在其中调用wait获得子进程的退出状态并打印。

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

子进程在死亡的时候会给父进程发送SIGCHLD信号

测试代码：

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

void handler(int signo)
{
     printf("pid: %d, %d 号信号，正在被捕捉!\n", getpid(), signo);
}

void Count(int cnt)//子进程活的时间
{
    while (cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}

int main()
{
    signal(SIGCHLD, handler);
    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id == 0)
    {
        printf("我是子进程, %d, ppid: %d,我要退出啦\n", getpid(), getppid());
        Count(5);
        exit(1);
    }
    while (1)//父进程什么都不做，但是也不退出，等子进程给父进程发信号！
        sleep(1);
    return 0;
}

以前父进程要等子进程退出，waitpid阻塞等待子进程，现在有了这个SIGCHLD信号，父进程就可以通过子进程给父进程发SIGCHLD信号，自定义SIGCHLD信号的处理动作（该信号的默认动作是忽略），就不需要父进程waitpid等待子进程了（父进程可以处理自己的工作，不用等待子进程了）。当子进程终止时会发送信号SIGCHLD信号给父进程，父进程调用实现准备好的信号处理函数（默认忽略直接不管了），在该函数里面调用wait/waitpid清理子进程就可以了

情况一：父进程有很多子进程，一次性子进程退完了
waitpid(-1) -> while(1) —— waitpid参数设置为-1，表示父进程等待任意一个子进程
父进程可能有很多个子进程，这些子进程一次性都退了，父进程是一次waitpid是等待不完了，必须while（1）循环式的waitpid等待才能等待完全部的子进程
直到循环的waitpid函数出错了，就表示我们父进程把所有的子进程等待完了

情况二：父进程有很多子进程，一次性只退一部分（这个时候waitpid函数是不会报错的，一直有子进程没有退出）
 while(1)
 {
     pid_t ret = waitpid(-1, NULL, WNOHANG);//必须以WNOHANG非阻塞的方式进行等待，因为父进程并不知道自己等待了多少个子进程退出：比如说：有10个子进程，只有5个子进程退出了，当父进程等待第6个子进程的时候，子进程没有退出，这里就相当于阻塞式等待，父进程就被挂起了（如果后续有任意一个子进程退出了还好，因为函数参数-1可以等待所有子进程，但是如果一直没有一个子进程退出，那么父进程就一直挂起等待子进程，什么都不干了），所以需要非阻塞等待
     if(ret == 0) break;//等于0就表示这一轮子进程，我父进程等待完了
 }

进程等待的信号版本：

 
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
 
void handler(int sig)
{
	 pid_t id;
	 while( (id = waitpid(-1, NULL, WNOHANG)) > 0)
	 {
		 printf("wait child success: %d\n", id);
	 }
	 printf("child is quit! %d\n", getpid());
}
 
int main()
{
	 signal(SIGCHLD, handler);
	 pid_t cid;
	 if((cid = fork()) == 0)
	 {//child
		 printf("child : %d\n", getpid());
		 sleep(3);
		 exit(1);
	 } 
	 while(1)
	 {
		 printf("father proc is doing some thing!\n");
		 sleep(1);
	 }
	 return 0;
}

其实我们父进程也是可以不需要等待子进程退出的！只需要父进程手动对SIGCHLD信号 进行忽略就行！并且这样子进程终止会立刻杀死，不会产生僵尸进程

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

void Count(int cnt)//子进程活的时间
{
    while (cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}

int main()
{
    // 显示的设置对SIGCHLD进行忽略
    signal(SIGCHLD, SIG_IGN);
    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id == 0)
    {
        printf("我是子进程, %d, ppid: %d,我要退出啦\n", getpid(), getppid());
        Count(5);
        exit(1);
    }
    while (1)
        sleep(1);
    return 0;
}

不对啊，既然SIGCHLD的默认动作是Ign也就是忽略，为什么还要我们手动设置SIG_IGN呢？

手动设置SIG_IGN不仅可以让父进程不用等待子进程，而且子进程退出的时候还不会变成僵尸进程
os在看到我们手动设置了SIG_IGN，那么就会对子进程pcb内部属性做一定的修改，达到进程退出时不会变成僵尸进程的效果

最后

signal(SIGCHLD, SIG_IGN);//SIG_IGN就是整数 1 只不过被强转了
signal(SIGCHLD, SIG_DFL);//SIG_DFL就算整数 0 只不过被强转了

8、总结

本期内容也是十分的作用，最重要的是搞清楚那几张图 —— pending表等等，那几张图搞懂了学起来就非常顺了！