Linux操作系统之信号：信号的产生

前言：

上篇文章我们大致讲解了信号的有关概念，为大家引入了信号的知识点。但光知道那些是远远不够的。

本篇文章，我将会为大家自己的讲解一下信号的产生的五种方式，希望对大家有所帮助。

一、键盘（硬件）产生信号

回顾

我们上文曾经说过，当我们在前台运行的一个进程时，尤其是while控制的死循环程序，我们可以通过按下ctrl + c按键来终止进程。

这是因为我们通过系统按键给进程发送了二号信号SIGINT，并杀死了该进程：

其中从34-64的信号我们这里不予关注，也用不上。我们只谈论前面31中信号。

我们当时通过signal系统调用接口，来自定义了对二号信号的处理方式handler。

其实忘记说的是，void handler(int signumber)中的参数signumber，其实就是该信号的编号。

而信号每一个信号如SIGINT，他其实都是一个宏定义：

我们可以通过man 7 signal，来查看更多信号的内容：

2号信号的默认处理方式是Term，也就是终止进程，另外，Core也是默认终止进程。

如果我们把一个进程的所有信号的默认处理方式都变成handler，会发什么什么情况呢？

：

cpp 复制代码

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

void handler(int signumber)
{
    std::cout<<"捕获到信号"<<signumber<<"，开始执行自定义处理方法"<<std::endl;
}

int main()
{
    for(int i=1;i<=31;++i)
    {
        signal(i,handler);
    }

    while(true)
    {
        std::cout<<"I am "<<getpid()<<" , I am waiting signal!"<<std::endl;
        sleep(3);
    }
    return 0;
}

难不成，所有信号都干不掉这个进程了吗？

这个问题，信号设计者自然也会想到，所以在信号中，就有几位信号的默认处理方式是无法改变的，九号信号就是这样。

信号位图

我们在按下键盘时，键盘会把信息交给操作系统，操作系统才向进程发送信号。

操作系统凭什么能收到键盘的信息啊？

：因为我们之前说过，操作系统是所有硬件的管理者，这一点我们在操作系统的那一章节说过。

同学们，我们说处理信号是在合适的时候而不是立即处理，那么，我们就必须把收到的信号保存起来。否则你不能及时处理，要等待，就会丢失信号。

那么进程是如何保管自己收到的信号的呢？

答案是：PCB

我们之前说每一个信号都有一个编号，并且编号刚好对应1-31，同学们，这你想到了什么？

：是不是位图啊！！

所以，在每一个进程的PCB中，存在一个位图，对应的比特位的0/1，就代表的是否收到对应的信号：

所以我们可以知道，发送信号，其实本质上不是发送，而是写入！！

写入信号！！：OS修改对应的进程的PCB中的信号位图：0->1。

同样的，我们说每一个信号都有一个对应的默认处理方法。这个方法又是怎么保存的呢？

参考一下我们的struct file中的操作表，在我们的task_struct中，也存在一个函数指针数组，分别存储对应下标的信号的默认处理方法：

硬件中断初体验

那么，操作系统是怎么知道键盘上有数据的呢？

难不成要操作系统一直在询问这些硬件吗？要知道，操作系统可是很忙的，基本什么事情，都有它的参与。

自然不会由操作系统主动去询问，这就跟你平时在公司上班，上头直接把任务分配给你，你完成了要给别人说一样。操作系统就是这个老板，硬件就是员工。

当按下鼠标，鼠标就会产生硬件中断，在冯诺依曼体系的帮助下，告诉操作系统我已经准备好了。

至此，操作系统就不用主动去知道键盘是否有数据，他只需要等别人告诉他。

这样，就实现了硬件与操作系统的并行执行。

操作系统通过中断管理所有硬件。那他内部管理进程，想模拟硬件的行为，于是就有了信号

二、指令

我们之前讲过，当我们想要对一个进程发送信号，我们只需要知道这个进程的pid，于是我们可以通过kill的系统指令，来给这个进程发送指定编号的信号：

所以我们这里就不再过多复述了。

三、系统调用

那么kill指令是怎么实现的呢？

它是根据kill系统调用来实现的：

第一个参数就是对应进程pid，第二个参数就是发送信号的编号或者宏。

至此，我们可以模拟实现一个我们的mykill程序：

cpp 复制代码

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

int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        std::cerr<<"Usage:" << argv[0] << " -signumber pid" << std::endl;
        return 1;
    }


    int n=::kill(atoi(argv[2]),atoi(argv[1]));

    return n;
}

第二个系统调用就是raise：raise 函数可以给当前进程发送指定的信号(就是自己给自己发信号)。

还有一个系统调用时abort：abort 函数使当前进程接收到信号而异常终⽌。

不难发现，后面两个调用的作用都是进行了特化，可以猜测他们的底层都调用了kill。

四、软件条件

我们当时在讲匿名管道的时候，提到过：

管道读端关闭，如果此时写端还想写入

操作系统就会直接终止该写端进程：这其实就是发送的13号信号

这歌案例就是软件条件不具备，你不具备写入的条件，于是要发送信号。

除了13信号外，还有一个14信号SIGALRM，这就涉及到了一个系统调用：alarm闹钟

alarm() 是 Unix/Linux 系统提供的 定时器函数 ，用于在指定时间后向当前进程发送 SIGALRM 信号（默认行为是终止进程）。它属于 <unistd.h> 头文件，常用于实现超时控制或周期性任务。这个闹钟是一次性的，你设置一次alarm函数，就会设置一个闹钟

我们运行程序：

cpp 复制代码

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

int main()
{
    int count = 0;
    alarm(1);
    while (true)
    {
        std::cout << "count : "
                  << count << std::endl;
        count++;
    }
    return 0;
}

就知道了一秒内的循环次数

我们一般会搭配上signal，使用自己的处理方法，这样就能实现一下特殊的代码：

cpp 复制代码

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


int count = 0;
void handler(int signumber)
{
    std::cout << "count : " << count << std::endl;
    exit(0);
}
int main()
{
    signal(SIGALRM, handler);
    alarm(1);
    while (true)
    {
        count++;
    }
    return 0;
}

诶，为什么后面这个代码while循环了这么多次呢？不都是一秒钟的闹钟吗？

这是因为：cout是阻塞式I/O操作，涉及用户态到内核态的切换，以及终端设备的输出

这些操作非常耗时，一秒钟的大部分时间花在 I/O 上，而非 count++。

而后面的操作就只涉及了count++，最后才会打印输出。

如果我们想设置重复闹钟呢？

就需要循环调用了：

cpp 复制代码

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

using func_t = std::function<void()>;

int gcount = 0;
std::vector<func_t> gfuncs;

// 把信号 更换 成为 硬件中断
void hanlder(int signo)
{
    for (auto &f : gfuncs)
    {
        f();
    }
    std::cout << "gcount : " << gcount << std::endl;
    alarm(1);
}

int main()
{
    gfuncs.push_back([]()
                     { std::cout << "我是一个内核刷新操作" << std::endl; });

    gfuncs.push_back([]()
                     { std::cout << "我是一个检测进程时间片的操作，如果时间片到了，我会切换进程" << std::endl; });

    gfuncs.push_back([]()
                     { std::cout << "我是一个内存管理操作，定期清理操作系统内部的内存碎片" << std::endl; });

    alarm(1); // 一次性的闹钟，超时alarm会自动被取消
    signal(SIGALRM, hanlder);

    while (true)
    {
        pause();
        std::cout << "我醒来了..." << std::endl;
        gcount++;
    }
}

如果时间才间隔快点，把信号更换为硬件中断，就是我们操作系统的运行原理

五、异常

我们都知道，当我们的代码出现除0或者使用野指针时，进程就会直接终止掉。

关于野指针我们在虚拟地址空间的时候曾经提到过：这是因为在页表上找该虚拟地址的映射关系时，找不到，或者权限不够，所以会被信号终止。

那么除零呢？

当我们出现除0异常时，会发送8信号（野指针是11）给我们的进程：

我们写以下代码：

cpp 复制代码

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

void handler(int num)
{
    std::cout<<"捕获到信号"<<num<<std::endl;
}

int main()
{
    signal(11,handler);
    signal(8,handler);

    int a=10;
     a/=0;
     int*p=nullptr;
     *p=10;
    while(true)
    {
        std::cout<<"hello world"<<std::endl;
    };
    return 0;
}

运行结果会无限打印：捕获到信号8.

这是为什么呢？

在我们的CPU上：

我们的操作系统需要知道CPU内部是否出错，（CPU也是一个硬件），就存在一个状态寄存器，负责判断此次的运算结果是否范围溢出等问题。（标记位为0表示正常，为1表示溢出）

当我们不终止进程，使用自己的处理方法，由于进程会轮循调度的原因，保存上下文信息，不终止进程就会一直调度该进程，发现溢出->发送信号，不断重复该过程

野指针越界访问也是类似的形式，当我们虚拟地址转化为物理地址成功时，会把地址存储在CR3中，如果失败，就会存储在CR2中，这样我们就知道出错了。

六、Core与Term

Core与Term都是终止进程，但是Core还做了一些特殊的处理。

如果是core的终止进程，在终止后会帮我们形成一个debug文件，通常是core或core.pid文件。

我们可以通过一些命令来看到出错的信息来调试。（或者gdb）

这里我就不在赘述，感兴趣的可以了解一下。

总结：

今天我们详细讲解的信号产生的五种方式，希望对大家有所帮助！！