👦个人主页：Weraphael
✍🏻作者简介：目前正在学习c++和算法
✈️专栏：Linux
🐋 希望大家多多支持，咱一起进步！😁
如果文章有啥瑕疵，希望大佬指点一二
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注😍
目录
一、通过终端按键产生信号
1.1 Ctrl + /
在上篇博客中（点击跳转），我们已经验证了Ctrl + c是向前台进程发送2号信号SIGINT来中断程序。
这篇再介绍一个组合键：Ctrl + \。它其实是向前台进程发送3号信号SIGQUIT来终止程序，同时会产生一个core文件。我们可以使用捕捉信号函数signal来验证。
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;
void myhandler(int signum)
{
// 修改的行为：打印信号编号后退出
cout << "信号编号为：" << signum << endl;
exit(1);
}
int main()
{
// 捕捉3号信号
signal(SIGQUIT, myhandler);
while (true)
{
cout << "我是一个进程，我在做死循环操作" << endl;
sleep(1);
}
return 0;
}
【程序结果】
其原理再简单重复一遍：当按下ctrl + \，操作系统识别到键盘上有数据，触发了硬件中断，CPU收到中断请求后，会暂停当前执行的程序，保存当前状态，并根据中断号来调用对应硬件的方法。由于操作系统识别到是特殊控制字符，就将其转化为3号信号发送给前台进程
1.2 Ctrl + z
Ctrl + z会向前台进程发送19号信号SIGSTOP。当进程收到此信号时，它会立即停止运行。
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;
int main()
{
while (true)
{
cout << "我是一个进程，我在做死循环操作" << endl;
sleep(1);
}
return 0;
}
【程序结果】
需要注意的是：19号信号SIGSTOP不能使用signal函数捕捉。类似地，9号信号SIGKILL用于立即终止一个进程，并且也不能被signal函数捕捉。
二、通过kill命令产生信号
kill -n <pid>
# n是信号编号
以以下代码为例：
#include <iostream>
#include <unistd.h>
using namespace std;
int main()
{
while (true)
{
cout << "进程:" << getpid() << ", 我在做死循环啦~" << endl;
sleep(1);
}
return 0;
}
【程序结果】
三、通过系统调用接口产生信号
3.1 kill
系统调用kill函数是用于向进程发送某种信号，其函数原型如下：
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
参数解释：
pid：要发送信号的进程pidsig：要发送的信号编号，可以是标准信号如SIGINT、SIGKILL，也可以是用户自定义的信号。- 返回值：成功时，返回
0；失败时，返回-1，并设置errno来指示错误的原因。
我们可以使用这个kill系统调用接口来模拟实现一个kill命令。首先kill命令必须是如下形式：
kill -信号编号 进程pid
那么这里就可以巧用main函数的参数。main函数的第一个参数argc：表示字符指针数组当中的有效元素个数。argv：是一个字符指针数组（向量表），数组以NULL指针结尾，注意argv的第一个值原因是程序名。
因此，代码如下：
#include <iostream>
#include <unistd.h>
#include <string>
#include <cstring>
#include <signal.h>
#include <sys/types.h>
using namespace std;
void Usage(string proc)
{
cout << "格式:\n\t" << proc << " signum pid\n\n";
}
// argv：程序名argv[0]、信号编号argv[1]、进程pid argv[2]
int main(int argc, char *argv[])
{
// 如果是三个参数,可以杀掉用户指定进程
if (argc == 3)
{
int signum = stoi(argv[1]);
pid_t pid = stoi(argv[2]);
int n = kill(pid, signum);
if (n != 0)
{
perror("kill");
exit(2);
}
}
// 如果不是输入三个参数，就提醒用户输入格式
else
{
Usage(argv[0]);
exit(1);
}
return 0;
}
接下来我再写一个死循环代码程序如下：
#include <unistd.h>
#include <iostream>
using namespace std;
int main()
{
while (true)
{
cout << "my pid is " << getpid() << endl;
sleep(1);
}
return 0;
}
【程序结果】
3.2 raise
raise函数用于向当前进程发送一个信号。它的基本形式如下：
#include <signal.h>
int raise(int sig);
sig：要发送的信号编号，可以是标准信号（如SIGINT、SIGTERM等），也可以是用户自定义的信号。- 返回值：成功时，返回
0；失败时，返回非0值。
这个函数可以这么理解：相当于一颗地雷，当程序“踩到”它，就会产生信号并执行。
例如：程序是死循环打印，当打印完3条消息后，就立马杀掉进程。
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
using namespace std;
int main()
{
int cnt = 3;
while (true)
{
cout << "My pid is " << getpid() << endl;
sleep(1);
cnt--;
if (cnt == 0)
{
// 9号信号
raise(SIGKILL);
}
}
return 0;
}
【程序结果】
这个函数通常搭配signal函数使用。因为有些信号终止程序不会像9号信号一样给killed提示，比方说2号信号SIGINT
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
using namespace std;
int main()
{
int cnt = 3;
while (true)
{
cout << "My pid is " << getpid() << endl;
sleep(1);
cnt--;
if (cnt == 0)
{
// 2号信号
raise(SIGINT);
}
}
return 0;
}
【程序结果】
当加了signal函数后，就直观很多了。代码如下：
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
using namespace std;
void handler(int signum)
{
cout << "我得到了2号信号SIGINT" << endl;
exit(1);
}
int main()
{
signal(2, handler);
int cnt = 3;
while (true)
{
cout << "My pid is " << getpid() << endl;
sleep(1);
cnt--;
if (cnt == 0)
{
// 2号信号
raise(SIGINT);
}
}
return 0;
}
【程序结果】
这个函数其实封装了系统调用接口kill，例如以上代码等价于kill(getpid(), 2);
3.3 abort
abort函数用于向自己发送一个6号信号SIGABRT，异常终止当前进程的执行。
函数原型如下：
#include <stdlib.h>
void abort(void);
【代码样例】
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
using namespace std;
void handler(int signum)
{
cout << "我得到了6号信号SIGABRT" << endl;
exit(1);
}
int main()
{
signal(6, handler);
int cnt = 3;
while (true)
{
cout << "My pid is " << getpid() << endl;
sleep(1);
cnt--;
if (cnt == 0)
{
abort();
}
}
return 0;
}
【程序结果】
值得一提的是，abort函数即使在修改执行动作后（没有exit(int)），最后仍然会发送6号信号来退出进程。
因此，abort函数也是被封装的，相当于kill(getpid(), 6);
总的来说，系统调用中举例的这三个函数关系是：kill包含raise，raise 包含 abort，作用范围是在逐渐缩小的
四、硬件异常产生信号
4.1 除 0 错误导致异常
程序异常本质是进程收到了某种信号。
比方说，我们可以使用signal函数来捕捉除0异常的进程收到了几号信号。
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
using namespace std;
void handler(int signum)
{
cout << "我收到了" << signum << "号信号" << endl;
}
int main()
{
for (int i = 1; i <= 31; i++)
{
signal(i, handler);
}
printf("1 / 0 = %d\n", 1 / 0);
return 0;
}
【程序结果】
从上我们发现：
- 操作系统发送
8号信号SIGFPE - 只发生了一次 除
0异常，进程非但没退出，还在死循环打印。
首先大部分进程对信号的处理行为都是终止程序，这里没有终止程序是因为我们修改了系统默认的行为，在handler函数最后一行补上exit函数即可正常终止。
但非常奇怪的是，我们代码中只有一次除0异常啊，正常来说只需要打印一次就行了，即使进程没有退出，将进程阻塞不就好了。为什么会一直死循环打印呢？想要明白背后的原理，需要先认识一下状态寄存器。
4.2 状态寄存器
代码中除
0和野指针行为，操作系统是怎么知道的呢？
在CPU中，存在很多寄存器，其中大部分主要用来存储数据信息，用于运算。除此之外，还存在一种特殊的 寄存器：状态寄存器。这个寄存器是一个位图结构。专门用来检测当前进程是否出现错误行为。如果有，就会把位图结构中对应的比特位置设置成1，意味着出现了异常。
当检测到状态寄存器中某个异常标志位被设置为1时，硬件（寄存器）会向CPU发送一个硬件中断，CPU收到来自硬件的中断信号后，又因为操作系统是这些硬件的“管理者”，它会暂停当前正在执行的进程。然后检查当前进程的上下文异常标志位的具体含义，以确定发生了什么样的异常。根据异常类型调用相应的异常处理程序。这些程序通常是预先定义好的。
所以现在就可以解释为什么进程收到来自操作系统的异常信号后，虽然我们修改了默认处理动作（不退出），但是会死循环打印的情况。这是因为操作系统一直检测当前进程的状态寄存器仍然处于异常状态，再加上不退出进程，此时进程一直在被调度运行，所以操作系统才会不断发送8号信号，才会死循环式的打印。
因此，异常信号被捕捉不是为了解决什么问题，而是让用户清除的知道程序是因为什么而挂掉的。
4.3 野指针异常
#include <iostream>
#include <unistd.h>
#include <cstring>
#include <string>
#include <signal.h>
using namespace std;
int main()
{
int *p = nullptr;
*p = 10;
return 0;
}
【程序结果】
Segmentation fault是一个段错误，这是每个C/C++程序猿都会遇到的问题，因为太容易触发了，出现段错误问题时，操作系统会发送11号SIGSEGV信号终止进程，这里不再证明演示。
那么 野指针问题是如何引发的呢？本质上就是：虚拟地址转化为物理地址失败。比方说：虚拟地址映射到不属于它的物理空间（越界访问）、对该物理空间没有写的权限等。具体解释如下：
当代的
MMU已经被集成在CPU内部，除此之外CPU还有一个寄存器，称为BadVAddr（Bad Virtual Address，坏虚拟地址）。这个寄存器的作用是在虚拟地址转换失败时，将引起异常的虚拟地址存储起来。所以，硬件（寄存器）会向
CPU发送一个硬件中断，CPU收到来自硬件的中断信号后，又因为操作系统是这些硬件的“管理者”，它会暂停当前正在执行的进程。然后检查当前进程的上下文异常标志位的具体含义，以确定发生了什么样的异常。根据异常类型调用相应的异常处理程序。这些程序通常是预先定义好的。
五、软件条件产生信号
异常不仅由硬件产生，还可以由软件产生！
比如我们之前的管道，如果一开始读写端都打开，但是关闭了读端，那么写端进程就会收到一个13号信号SIGPIPE。这就是一种软件异常。【Linux】进程间通信之匿名管道
5.1 alarm 函数
alarm函数是一个系统调用接口，用来设置一个定时器。其功能是：在指定的秒数后发送14号信号SIGALRM给调用进程。该信号的默认处理动作是终止当前进程。
原型如下：
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
seconds：指定的秒数，即多少秒后发送SIGALRM信号。如果参数为0，则任何已设置的定时器都会被取消，但不会产生信号。- 返回值：返回调用之前的剩余定时器时间。如果之前没有设置定时器，则返回
0。 aralm函数的原理：我们知道每个进程都可以使用alarm设置闹钟，所以操作系统中一定有大量的闹钟。所以操作系统要管理闹钟，所以闹钟就会用struct结构体描述，一定有进程pid（表示哪个进程设置的闹钟）等字段，然后用链表等数据结构管理起来。这样所谓的闹钟管理就变成了对链表等的增删查改。操作系统底层中alarm的底层所用的时间用的是时间戳，只要系统的当前时间大于等于里面设置的时间，就会发送信号。我们遍历链表的时候是比较浪费时间的。所以用一个小堆是最简单的。
【代码样例】
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;
int main()
{
// 设定一个5s的定时器
alarm(5);
int n = 1;
while (true)
{
cout << "我是一个进程，已经运行了 " << n++ << " 秒 PID: " << getpid() << endl;
sleep(1);
}
return 0;
}
【程序结果】
那我们就可以在执行主要任务的同时，去定时完成其他任务了。例如：
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
using namespace std;
void work()
{
cout << "我在完成其他任务" << endl;
}
void handler(int signum)
{
// 异常捕捉时，再设置一个定时器完成其他任务
alarm(5);
work();
}
int main()
{
// 设定一个5s的定时器
alarm(5);
// 信号捕捉
signal(14, handler);
int n = 1;
while (true)
{
// 主要任务
cout << "我是一个进程，已经运行了 " << n++ << " 秒 PID: " << getpid() << endl;
sleep(1);
}
return 0;
}
【程序结果】
六、核心转储 core dump
6.1 知识回顾
我们可以使用以下命令来看信号的详细信息手册
man 7 signal
我们可以注意到，常见的信号中大部分是终止Term(terminate)信号的。还有一些是暂停(Stop)，继续（Cont），忽略(Ign)。
那么这个核心Core是什么东西呢？
在我们当时学习进程控制的时候，还有一个这个字段core dump标志我们还没提到过（【Linux】进程控制 ）
当一个进程异常退出时（参看上面Action为Core信号），该core dump标志会被设置成1，并且会生成一个core.pid二进制文件，然后不再设置退出码（为0，因为这种情况下程序没有正常的执行路径结束）
我们可以写代码来验证一下：
#include <iostream>
#include <unistd.h>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
int main()
{
pid_t pid = fork();
if (pid == 0) // 子进程
{
int cnt = 500;
while (cnt--)
{
cout << "I am child process, pid:" << getpid() << ", cnt:" << cnt << endl;
sleep(1);
}
// 打印5句话后子进程退出
exit(1);
}
else // 父进程
{
int status = 0;
pid_t rid = waitpid(pid, &status, 0);
if (rid == pid)
{
cout << "child quit info, rid:" << rid << ", exit code:" << ((status >> 8) & 0xff)
<< ", exit signal:" << (status & 0x7f) << ", core dump:" << ((status >> 7) & 1)
<< endl;
}
}
return 0;
}
【程序结果】
为什么没有生成核心转储文件啊？难道是我们的环境有问题吗？
确实，当前环境确实有问题，因为它是云服务器，而云服务器中默认是关闭核心转储功能的。
6.2 打开与关闭核心转储
通过以下指令可以查看当前系统中的资源限制情况
ulimit -a
可以看到，当前系统中的核心转储文件大小为0，即不生成核心转储文件。
通过以下指令手动设置核心转储文件大小（打开核心转储文件）
ulimit -c <大小自己定>
# 关闭大小设置为0即可
# 重启xhell自动关闭
我们可以再来测试一下，是否dump core是否还为1：
我们观察到：核心转储文件是很大的。
6.3 核心转储的作用
当一个进程在出现异常的时候，操作系统会将进程在内存中的运行信息进行核心转储，转储到当前进程的运行目录下（磁盘），形成core.pid这样的二进制大文件（核心转储文件）。
核心转储的作用是什么呢？
答案是：调试（事后调试），并且直接从出错的地方开始调试。
以下是调试样例代码
#include <iostream>
using namespace std;
int main()
{
int a = 1;
int b = 0;
a = a / b;
cout << "a = " << a << endl;
return 0;
}
调试方法如下（四个步骤）：
- 首先
gcc/g++在编译时加-g生成可调试文件
- 运行程序，生成 core-dump 文件
gdb 可执行文件进入调试模式
- 在
gdb命令行输入：core-file <核心转储文件>。即利用核心转储文件，快速定位至出错的地方。
最后一个问题：既然核心转储文件这么好用，为什么大多数的云服务器默认是将它关闭的呢？
现在许多大型IT公司以及许多中小型企业，都倾向于使用云服务器来托管其后端服务和应用程序。如果打开的话，当应用程序如果收到某个信号，核心转储文件会在进程的当前目录下创建一个大文件。而有很多进程都可能会产生核心转储文件，当文件足够多时，磁盘被挤满，导致系统IO异常，最终会导致整个服务器挂掉的，所以云服务器一般默认是关闭的。
![[<span style='color:red;'>Linux</span>][<span style='color:red;'>进程</span><span style='color:red;'>信号</span>][一][<span style='color:red;'>信号</span>基础][如何<span style='color:red;'>产生</span><span style='color:red;'>信号</span>]详细解读](https://img-blog.csdnimg.cn/direct/b171d4219ce84cc18ff34cf947945ff4.png)
