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

Linux进程信号（信号的产生）

article 2024/11/14 11:33:09

什么是信号？

信号的产生

信号产生方式1：键盘

前台进程

后台进程

查看信号

signal系统调用

案例

理解进程记录信号

软件层面

硬件层面

信号产生方式2:指令

信号产生方式3:系统调用

kill系统调用

案例

其他产生信号的函数调用

1.raise

2.abort

信号产生方式4:软件条件

什么是软件条件？

alarm系统调用

使用

信号的产生5:异常

示例1：

示例2：

那么os如何知道进程内部错误？

理解一下野指针的异常

Term和Core的区别

什么是信号？

信号！=信号量

信号：是一种用户,OS,其他进程，向目标进程发送异步事件的一种方式。

同步和异步：

1.怎么识别信号？

识别信号是内置的。即进程识别信号时程序的内置属性。可以类比一下语言的内置数据类型（int，double）

2.信号产生后，进程知道怎么处理吗？知道。如果没产生，进程知道怎么处理吗？也知道，因为信号的处理方法在产生之前就已经准备好了。

3.信号会被进程立即处理吗？

不一定，如果不，那么什么时候处理呢？进程会在一个合适的时候处理。

信号到来 --> <进程不立即处理，记录信号> --> 合适的时候处理信号

4.处理信号的方法： 1.默认行为 2.忽略信号3.自定义动作

信号的产生

信号产生方式1：键盘

这有一段死循环的程序

#include <iostream>
#include <unistd.h>
int main()
{
    while (true)
    {
        std::cout << "hello world" << std::endl;
        sleep(1);
    }
    return 0;
}

从键盘中输入 ctrl+c 可以前台进程杀掉前台进程。

前台进程

命令： ./程序名

运行起来的是前台进程也可以用ctrl+c杀掉进程

后台进程

命令： ./进程名&

后台进程无法用 ctrl+c 杀死

杀掉后台进程的方法：1. fg命令将后台进程切换到前台，在ctrl+c杀掉进程。

2. kill -9 pid(对应进程的pid）

方法一：

方法二：

查看信号

kill -l

man 7 signal//中可以找到相应信号的描述

signal系统调用

信号的自定义捕捉

signal的作用是捕捉signum号信号，捕捉之后，执行handler指向的函数

signum：要捕捉的信号

#define SIGQUIT 3

handler：处理函数

案例

ctrl+\ 默认终止进程

#include <iostream>
#include <unistd.h>
#include <signal.h>
void handler(int signo)
{
    std::cout << "signo: " << signo << std::endl;
}
int main()
{
    //捕捉  3)SIGQUIT信号
    signal(SIGQUIT, handler);
    while (true)
    {
        std::cout << "hello world" << std::endl;
        sleep(1);
    }
    return 0;
}

ctrl+\，被捕捉不再执行默认行为（默认终止），而是将这个信号传给signo并调用自定义函数

根据上面的案例是不是我们捕捉所有信号，那么这个死循环程序就不会被杀死了呢？

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
using func_t = std::function<void(int)>;
void handler(int signo)
{
    std::cout << "signo: " << signo << std::endl;
}
int main()
{

    //signal(SIGQUIT, handler);
    //捕捉信号
    for(int i = 1;i<=31;i++)
    {
        func_t f = signal(i,handler);
        std::cout<<"捕捉:"<<i<<std::endl;
    }
    while (true)
    {
        std::cout << "hello world" << std::endl;
        sleep(1);
    }
    return 0;
}

从结果上可以知道ctrl+c ctrl+\因为被捕捉了，所以杀不掉进程，但kill -9 可以杀掉进程，也就说明了，9）SIGKILL 不能被捕捉。

理解进程记录信号

软件层面

键盘（比如ctrl+c） -> os -> 进程 --> 记录信号

因为os管理外设，所以键盘将信号传给os，os也管理进程，os在将信号传给进程，之后进程记录信号。

进程如何记录信号？

总结：

发送流程：键盘中的信号发送给os，os在发送给进程，修改进程对应的信号位图和其维护处理方法的函数指针数组。

无论什么信号都是由os发送的。

os是task_struct的唯一管理者，所以只有 os有权利修改信号位图。

硬件层面

os是如何知道键盘上有数据？

轮徇（不可以，os的任务太多了）

硬件中断

冯诺依曼体系结构

在数据层面上，我们知道cpu不与外设直接打交道。而是通过存储器

但在cpu和键盘是连接的，键盘可以直接将数据交给cpu

硬件中断 --> cpu告诉os，键盘上有数据 --> 这样硬件和os就可以并行执行了

信号vs信号中断

信号是纯软甲的

信号中断是纯硬件的

信号产生方式2:指令

指令：

kill -信号 相应进程的pid

信号产生方式3:系统调用

kill系统调用

kill的作用：就是OS向（pid)进程发送sig信号

使用代码：

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
int main()
{
    int cnt= 5;
    while(true)
    {
        std::cout<<cnt<<std::endl;
        if(cnt<=0)
            kill(getpid(),SIGQUIT);
        sleep(1);
        cnt--;
    }
    return 0;
}

执行结果：

kill()系统调用与kill命令的关系

kill命令行就是封装的kill()系统调用。

案例

简单实现下自己的kill

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


void Usage(char* argv)
{
    std::cout<<"Usage error: "<<argv<<" signo"<<" pid"<<std::endl;
    exit(1);
}
//./kill 9 pid


int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        //正确使用提醒
        Usage(argv[0]);
    }

    int signo = std::stoi(argv[1]);
    pid_t pid = std::stoi(argv[2]);
    int ret = kill(pid,signo);
    
    if(ret<0)
    {
        perror("kill");
        exit(2);
    }
    return 0;
    
}

执行结果：

其他产生信号的函数调用

1.raise

作用：让OS向调用该函数的进程返送sig信号

2.abort

作用：让OS向调用该函数的进程返送6号信号（该进程被干掉）

这两个函数比较简单

这两个函数都是由kill封装的,libc库函数

kill(getpid(),sig);//raise
kill(getpid(),6);//abort

信号产生方式4:软件条件

什么是软件条件？

由软件条件产生信号，通常指的是在软件应用程序中，根据某些特定的条件或逻辑判断来触发或生成信号

比如：管道中，读端关闭，但写端没有关闭这时，os回想进程发送 13）SIGPIPE信号

alarm系统调用

作用：设置一个seconds秒的闹钟，时间一到就会给调用闹钟的进程发送 14）SIGALRM信号

alarm(条件)；

里面设置的时间就相当于条件，满足条件就发送信号。

OS中维护的定时器的大概内核数据结构

使用

1.

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


int main()
{
    alarm(1);
    int cnt = 0;
    while(true)
    {
        //一秒打印多少次
        std::cout<<cnt<<std::endl;
        cnt++;
    }
    return 0;
}

结果：

打印了11万多次，快只能说很慢。

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



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

结果：计算了将近16亿次

从上面两个程序可以看出，IO影响计算速度。

2.

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



int main()
{
    alarm(5);
    sleep(1);
    int n = alarm(0);//alarm(0)取消闹钟   n上一个闹钟剩余的时间
    std::cout<<n<<std::endl;
    return 0;
}

3.

pause

作用：等待信号

闹钟是一次性的发送完信号后就被取消。

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
#include <vector>
using func_t = std::function<void()>;

int cnt = 0;
std::vector<func_t> v;//任务

void handler(int signo)
{
    for (auto &e : v)
    {
        e();
    }
    alarm(2);
    cnt++;
}
int main()
{
    v.push_back([]()
                { std::cout << "我是一个日志任务" << std::endl; });
    v.push_back([]()
                { std::cout << "我是一个下载任务" << std::endl; });
    v.push_back([]()
                { std::cout << "我是一个mysql任务" << std::endl; });
    alarm(2);//一次性闹钟，超时后就会被取消
    signal(SIGALRM, handler);
    while (true)
    {
        pause();//等待信号
        std::cout << "我醒来了..." << std::endl;
        std::cout << "cnt: " << cnt << std::endl;
    }
}

运行结果：

将上述逻辑中的信号变为硬件中断，就是OS的运行逻辑。

OS本质上就是一个中断处理程序

信号的产生5:异常

示例1：

野指针

int main()
{
    int *p = nullptr;
    *p = 0;//野指针
    return 0;
}

Segmentation fault 段错误

11)SIGEGV

示例2：

int main()
{
    int a = 10;
    a/=0;
    return 0;
}

Floating point exception 浮点异常

8）SIGFPE

现在我们可以理解一下为什么程序会崩溃？
出现错误时，OS会向进程发送相应的信号，从而进程被干掉。

那么os如何知道进程内部错误？

比如：div 0

cpu中有状态寄存器 Eflag，Eflag中有个core dump（溢出标记为）标记为，1.cpu计算错误

0.无错误

验证：

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

int main()
{
    pid_t pid = fork();
    if(pid==0)
    {
        //子进程
        int a = 10;
        a/=0;
    }
    else
    {
        int status;
        waitpid(pid,&status,0);
        std::cout<<"core dump: "<<((status>>7)&1)<<std::endl;
        std::cout<<"signo: "<<(status&0x7F)<<std::endl;
    }
}

结果：

正如所料：core dump被设为1，并向子进程发送8）SIGFPE信号

--------------------------------------------------------------------------------------------------------------------------------

void handler(int signo)
{
    std::cout<<"signo: "<<signo<<std::endl;
}
int main()
{
    pid_t pid = fork();
    if(pid==0)
    {
        //子进程
        int a = 10;
        a/=0;
    }
    else
    {
        int status;
        waitpid(pid,&status,0);
        std::cout<<"core dump: "<<((status>>7)&1)<<std::endl;
        std::cout<<"signo: "<<(status&0x7F)<<std::endl;
    }
}

差不多的程序如果捕获了8号信号，

结果：

os一直发送8号信号。

总结：

cpu错误 --> 谁弄坏了cpu，os发送信号杀死进程（--> 如果捕捉了8号信号--->进程没退出--->还要调度-->还要切换执行等 --> os不会修复Eflag中core dump（1）-->一直触发信号）

理解一下野指针的异常

野指针的错误是由cpu中MMU错误引起的

Term和Core的区别

Trem：正常终止，不需要debug

Core：核心转储--->在当前目录下形成core文件-->进程崩溃，将进程在内存中的部分信息保存起来，方便以后调试-->一般被云服务器关闭（如果崩溃一次形成一个新的core，那么就可能把磁盘空间占满）

但当前目录下没有啊

如何打开？

ulimit -a//查看

可以看到core file size为0；

ulimit -c 大小//改变core file size

readelf -S  ./sig  //查看程序elf格式

运行程序就可已生成core.pid的文件

如果无法生成core文件的话

在root下，输入下面的命令就可以了

echo core > /proc/sys/kernel/core_pattern

core-file core.pid//方便调试

如果是子进程异常呢？core的生成条件？

core dump--> 退出信号的终止动作是core && 云服务器开启core

查看全文

http://www.kler.cn/a/388749.html

【嵌入式开发】单片机CAN配置详解

边缘计算在智能交通系统中的应用

ima.copilot-腾讯智能工作台

Lucene 和 Elasticsearch 中更好的二进制量化 (BBQ)

【VBA实战】用Excel制作排序算法动画续

Gsensor加速度传感器数据异常及概率性卡死

你对安装在自己网站上的wordpress插件了解吗?

【C语言】浮点型数据存储和整型数据存储的区别

基于深度学习的路面裂缝检测算法matlab仿真

C#-运算符重载

Redis运行时的10大重要指标

1688拿货经验分享：亚马逊中小卖家如何选合作厂家

JS面试题之---解释一下什么是闭包？

【日常经验】RPC 调用的分类及示例

非关系型数据库NoSQL的类型与优缺点对比

API接口精准获取商品详情信息案例

【前端】Svelte：响应性声明

动态规划（二）——路径问题

Android13 系统/用户证书安装相关分析总结(三) 增加安装系统证书的接口遇到的问题和坑

VScode配置C、C++环境，编译并运行并调试

Java之List常见用法

VUE3实现好看的通用网站源码模板

深度学习经典模型之VGGNet

＜＜零基础C++第一期，C++入门基础之引用知识点＞＞

JavaWeb--Maven

系统安全第五次作业题目及答案

什么是信号？

信号的产生

信号产生方式1：键盘

前台进程

后台进程

查看信号

signal系统调用

案例

理解进程记录信号

软件层面

硬件层面

信号产生方式2:指令

信号产生方式3:系统调用

kill系统调用

案例

其他产生信号的函数调用

1.raise

2.abort

信号产生方式4:软件条件

什么是软件条件？

alarm系统调用

使用

1.

2.

3.

信号的产生5:异常

示例1：

示例2：

那么os如何知道进程内部错误？

理解一下野指针的异常

Term和Core的区别

相关文章：