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表等等,那几张图搞懂了学起来就非常顺了!