当前位置：首页 > news >正文

Linux 信号（下篇）

news 来源：原创 2025/8/13 23:40:49

Linux 信号-CSDN博客（上篇）

前言：在我上一篇博客写到了信号产生的三种条件分别是键盘组合键、kill命令、系统调用接口；

接下来我要把信号产生剩余的两个条件介绍完毕并理解信号的保存，和信号从产生到保存到处理整个过程！

一、信号的产生

1.1、条件四 --- 异常

我们知道当代码运行时出现除0错误或者对空指针的解引用时程序会报错并终止，接下来我将编写一段代码发生除零错误，看看程序异常后是接收到了什么信号？

代码：

//mysignal.cc
#include <iostream>
using namespace std;
#include <signal.h>//信号接口调用头文件
#include <unistd.h>//sleep 头文件
void handler(int signum)
{cout<<"signum is:"<<signum<<endl;//自定义方法只向屏幕打印信号数字，不做任何处理sleep(1);
}
int main()
{typedef void(*sighandelr_t)(int);//定义类型for(int i=0;i<31;i++)//把1~31号信号全捕捉{signal(i,handler);//捕捉到就会执行自定义方法}int a=10;a/=0;//除零错误会发生异常return 0;
}

makefile：

mysignal:mysignal.ccg++ -o $@ $^ -std=c++11
.PHONY:clean
clean:rm -f mysignal

编译后运行：

我们观察到除零错误接收到的是8号信号！！但是很奇怪的现象是：它一直在循环打印！

明明我自定义的方法是打印一次信号数字，并休眠1秒！

我们先来看看8号信号是什么：

SIGFPE-> FPE -> Float point exception! 意思就是浮点异常，也就是除0错误，没问题！

那么究竟是谁给进程发的信号？怎么发的？为什么会一直在打印？

1.2 异常的过程

首先我们能肯定的是一定是操作系统，因为操作系统是所有硬件的管理者，而且肯定是某个硬件在处理这个数据的时候发生了错误导致硬件报错反馈给操作系统，然后操作系统给这个进程发信号！！->>

在计算机中能对数据进行处理和运算的一般都是cpu，所以这个硬件可以确定是cpu！

我们可以大致画出一个图来：

①、代码运行起来后变成进程，进程被cpu调度，当cpu执行到代码a/=0;这行代码的时候检测到错误的发生；

②、在cpu的状态寄存器中，溢出标志位标记到这个除0错误；

③、cpu报错硬件异常，告诉操作系统这行代码不行运算不出来；

④、操作系统接收到cpu的报告后给task_struct进程发了一个8号信号；

⑤、进程中的代码有一个捕获信号的调用接口，捕获到了8号信号，并运行自定义方法向显示器文件打印信号数；

⑥、然后这个进程被cpu扔了出来；

⑦、这个进程并没有结束，接着又被cpu调度，接着又发生cpu硬件异常，接着又跟OS报告，接着OS又向这个进程发信号，接着这个进程又捕获信号并向显示器打印.........不停地重复步骤①②③④⑤⑥⑦...............

所以才有了刚才运行后的那一幕；

总结就是：CPU一直调度进程，一直发生硬件报错，一直跟OS报告，OS一直向进程发送信号，进程一直捕获信号并打印，进程处于死循环状态！！

1.3思考为什么OS不直接把进程杀掉而是给进程发信号？

因为：

①、如果这个进程在处理非常重要的数据跟文件呢？单单一个错误就把整个进程杀掉，那么这些重要的数据的丢失责任谁来承担？所以OS不想背黑锅，没有把进程杀死而是给你个信号，给你个提醒，怎么做处决于用户！

②、不要想着发生异常后把它捕获然后自己用什么办法来解决，OS给你发信号是让你死的明白、是让你处理后事工作（该保存的数据保存好等），并不是让你来解决问题的！

1.4 信号产生条件五 --- 软件条件

不是只有硬件异常才会产生信号，软件也会；

例如：闹钟接口：

#include <unistd.h>
unisigned int alarm(unsigned int second);
//1. 这是一个设置闹钟的接口
//2. second ： 设置的时间，一旦时间到了给进程发闹钟信号
//3. 返回值是上一个闹钟设置剩余的时间

代码：

#include <iostream>
using namespace std;
#include <signal.h>//信号接口调用头文件
#include <unistd.h>//sleep 头文件
typedef void(*sighandler_t)(int);
void handler(int signum)
{cout<<"signum is:"<<signum<<endl;int n=alarm(5);//设置一个5秒后提醒的闹钟cout<<"闹钟剩余时间："<<n<<endl;
}
int main()
{signal(SIGALRM,handler);//捕获闹钟信号alarm(50);//设置一个50s后提醒的闹钟while(1){cout<<"i am a process!!"<<"pid is:"<<getpid()<<endl;sleep(1);}return 0;
}

运行：（运行一会给它发闹钟信号，看看剩余时间）

捕捉到信号后继续设5秒闹钟，然后就会看到每隔五秒打印一次signum和剩余时间：

二、core dump功能

2.1 core dump 标志位

每个信号都都有其对应的执行动作，我们输入命令 man 7 signal 可以查看到，其中命令的执行动作有 Term、Core、Cont、Stop；其中Term、Core都是终止动作，Cont、Stop为继续和暂停动作

那么Core跟Term有什么区别呢？

我们回忆一下在进程等待的时候，父进程获取子进程的退出状态，把退出状态保存在status这个整形中，当程序是正常终止的时候，次八位存放的是进程的退出状态；当进程是被信号所杀的时候，低八位中，前7位存放的是终止信号，第八位存放的是core dump标志位：

2.2、获取core dump标志位

int main()
{pid_t id=fork();if(id<0)return -1;else if(id==0){int cnt=100;while(cnt--){cout<<"i am child process"<<"process id :"<<getpid()<<endl;sleep(1);}exit(0);}//fartherint status=0;pid_t n=waitpid(id,&status,0);if(n==id){cout<< "process exit code:"<<(status>>8&0xFF)<<"!!  process exit signal:"<<(status&0x7F)       <<"!! core dump:"<<((status>>7)&1)<<endl;  //0x7F=0111 1111(低7位是保存终止信号)//&1 1 = 00000000 00000000 00000000 00000001}return 0;
}

编译运行并向这个程序发送8号信号，我们发现获取到的core dump是0 （8号信号的执行动作是core，应该是1 才对），这是因为服务器默认是关闭core dump功能的！

2.3、打开系统的core dump功能后再运行

命令：ulimit -a 查看 core file ：

命令： ulimit -c 1024 设置core file 大小后查看：

这样表示打开了系统的core dump 功能，再运行程序，再给进程发8号信号：

我们看到，core dump变为1 了！

然后查看当前目录发现多了一个core.640这样一个文件！

当我们打开系统的core dump功能后，一旦进程出现异常，OS会将进程在内存中的运行信息给dump（转储）到进程的当前目录（磁盘）中，形成core.pid文件，这就是核心转储！

这个文件有什么用呢？有了这个文件，当我们调试的时候会直接定位到出错的那一行代码中，这是先运行再调试（事后调试）的方法；

我们可以gdb调试看看：

改一下代码：

int main()
{int a=10;int b=0;int c=a/b;//除0错误cout<<c<<endl;return 0;
}

运行后发现多了一个括号（core dumped）意思是已被转储，再没开启core dump功能时没有这个括号提示的：

然后在查看当前目录：

然后gdb调试：

进去后输入刚才转储的文件core.8366

按回车后直接跳转到程序运行时出错的地方，并告诉你出错原因：

进程终止因为收到的8号信号，出错在第65 行代码 int c=a/b;中！

2.4、总结 core dump

①核心转储功能，用来当进程出错的时候把运行时的出错信息保存在程序当前目录下，文件名为core.pid;

②当以后调试的时候直接打开core文件就可以快速定位到出错的那一行代码；

③为什么服务器要把core dump功能关掉？

因为：如果不关掉，一旦进程出现异常终止后就会在进程的当前目录下创建core文件并保存其运行时的信息；不要忘记了当程序异常的时候OS并没有直接把它杀死掉，而是让用户自己决定，如果用户没有让进程结束，cpu会一直调度这个进程并一直出异常并一直创建core文件在其当前目录下！那么一下子会把服务器磁盘填满，这样服务器就会崩溃！

三、信号的保存

3.1、信号是如何保存起来的？进程是如何管理这么多信号的？

三张表：

①第一张表，block，用位图结构跟每个信号建立起映射关系，当这个信号被屏蔽时，对应的位置由0置成1，当取消屏蔽时对应的位置由1置0；

②第二张表，pending，用位图结构跟每个信号建立起映射关系，当产生这个信号时，对应的位置由0置成1，当这个信号被处理之后再由1置成0；

③第三张表，handler，相当于一个指针数组，当这个信号需要处理的时候就调用指针指向的方法；

注意区分几个概念：

信号的屏蔽跟信号是否产生没有任何关系；

信号被屏蔽=信号不会被递达=信号不会被处理；

信号未决=信号已产生且未被处理；

3.2、做个测试

我们把1~31号信号都屏蔽了，然后给这个进程发信号，看看这个进程是否对所有信号都没有反应，同时不停地打印pending表（已产生但未处理）的数据：

介绍待会用到的接口：

#include <signal.h>
int sigprocmask( int how, const sigset_t* set, sigset_t* oset);
//1. 这是用来操作block表的一个接口
//2. how : 可以设置为 SIG_BLOCK/SIG_ONBLOCK/SIG_SETMASK ,当设置为SIG_SETMASK时是对信号的屏蔽
//3. sigset_t : 是系统封装好的位图结构体； set:提前准备好的数据，里面已经设置好你想要屏蔽的信号；oset：把老的位图，更改前的位图数据从内核中带出来

#include <signal.h>
int sigpending (sigset_t *set);
//1. 这是一个获取pending表的接口
//2. 返回值获取失败<0;

#include <signal.h>
int sigemptyset(sigset_t*set);
//sigemptyset是初始化set所指向的信号集，让其中所有的信号的对应的比特位清零

#include <signal.h>
int sigaddset(sigset_t * set,int signo);
//这是把某个特定的信号加上的接口

#include <signal.h>
int sigismember(sigset_t *set, int signo);
//1. 这是一个检测信号signo是否已经存在set表中，存在代表signo信号已产生
//2. 如果信号不存在信号集内返回0，如果信号存在信号集内返回1，如果失败返回-1；

代码：

//mysignal.cc
#include <iostream>
using namespace std;
#include <signal.h>//信号接口调用头文件
void printPending(sigset_t & pending)
{for(int i=1;i<=31;i++)//1~31号信号，只要已经产生了就打印出来{if(sigismember(&pending,i))//判断信号i是否存在pending表中，存在代表这个信号已产生cout<<"1";elsecout<<"0";}cout<<endl;
}
int main()
{//1. 屏蔽前的数据准备sigset_t bset,oldset;sigemptyset(&bset);//清空信号集sigemptyset(&oldset);for(int i=1;i<=31;i++){sigaddset(&bset,i);//增加1~31号信号}//2.调用系统调用接口int n=sigprocmask(SIG_SETMASK,&bset,&oldset);//到这里已经屏蔽了1~31号信号if(n<0)return -1;//3.打印pendingsigset_t pending;while(true){int n=sigpending(&pending);//获取内核中pending表到 pending中；if(n<0)continue;//如果获取失败继续获取printPending(pending);//获取成功打印pending表sleep(1);}return 0;
}

编译运行后，给这个进程发1~31号信号：

经过测试除了9跟19号信号不能被屏蔽之外，其他信号都可以被屏蔽，因为9、19号信号为杀掉进程、暂停进程！！

3.3、取消信号屏蔽

我们让程序打印5次之后取消所有信号的屏蔽，然后我们自己给进程发1号信号：

结果进程退出，收到对应1号信号！！！

四、理解内核态和用户态

4.1、信号是如何被处理的？什么时候被处理的？

当我们的进程从内核态返回用户态的时候，进行信号的检测和处理！

当我们调用系统调用的时候，操作系统自动会做“身份”切换，由用户身份变成内核身份，当系统调用完成后，再由内核身份切换为用户身份；

其中内核态：允许访问操作系统的代码和数据！

用户态：只能访问自己的代码和数据！

4.2、信号产生到处理整个过程（程序由用户态->内核态->用户态->内核态->......）

注意：进程就是不断地在用户态和内核态之间进行切换，因为操作系统不相信用户，操作系统的资源跟数据不可能让用户随意访问，只能通过系统调用接口访问，且当访问的时候需要切换为内核态身份！！

注意：不是只有系统调用才会切成内核态！

今天的分享就到这里！！如果对你有所帮助记得点赞收藏+关注哦！！谢谢！！！

咱下期见！！！