Linux从青铜到王者第十一篇:Linux进程间信号第一篇

Posted 森明帮大于黑虎帮

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Linux从青铜到王者第十一篇:Linux进程间信号第一篇相关的知识,希望对你有一定的参考价值。

在这里插入图片描述

系列文章目录

  • 本节重点:
  • 掌握Linux信号的基本概念。
  • 掌握信号产生的一般方式。
  • 理解信号递达和阻塞的概念,原理。
  • 掌握信号捕捉的一般方式。
  • 重新了解可重入函数的概念。
  • 了解竞态条件的情景和处理方式。
  • 了解SIGCHLD信号, 重新编写信号处理函数的一般处理机制。


前言


在这里插入图片描述

一、信号入门

1.生活角度的信号

  • 你在网上买了很多件商品,再等待不同商品快递的到来。但即便快递没有到来,你也知道快递来临时,你该怎么处理快递。也就是你能“识别快递”。
  • 当快递员到了你楼下,你也收到快递到来的通知,但是你正在打游戏,需5min之后才能去取快递。那么在在这5min之内,你并没有下去去取快递,但是你是知道有快递到来了。也就是取快递的行为并不是一定要立即执行,可以理解成“在合适的时候去取"。
  • 在收到通知,再到你拿到快递期间,是有一个时间窗口的,在这段时间,你并没有拿到快递,但是你知道有一个快递已经来了。本质上是你“记住了有一个快递要去取"。
  • 当你时间合适,顺利拿到快递之后,就要开始处理快递了。而处理快递一般方式有三种:1. 执行默认动作(幸福的打开快递,使用商品)2. 执行自定义动作(快递是零食,你要送给你你的女朋友)3. 忽略快递(快递拿上来之后,扔掉床头,继续开一把游戏)。
  • 快递到来的整个过程,对你来讲是异步的,你不能准确断定快递员什么时候给你打电话。

2. 技术应用角度的信号

  • 用户输入命令,在Shell下启动一个前台进程:
  • 用户按下Ctrl+C ,这个键盘输入产生一个硬件中断,被OS获取,解释成信号,发送给目标前台进程。
    在这里插入图片描述
  • 前台进程因为收到信号,进而引起进程退出。
     1	#include<iostream>
     2	#include<unistd.h>
     3	int main()
     4	{
     5	    while(1)
     6	    {
     7	        std::cout<<"i am process,i am waiting signal!"<<std::endl;
     8	        sleep(1);
     9	    }
    10	    return 0;
    11	}
  • 请将生活例子和 Ctrl-C 信号处理过程相结合,解释一下信号处理过程。
    假设你的快递到了,快递员就像操作系统一样给进程发信号,快递员则打电话给你说你快递到了,然后我自己说等下下去取。就像使用键盘敲出ctrl+c一样给操作系统,然后操作系统发送信号给进程,进程然后终止。
  • 进程就是你,操作系统就是快递员,信号就是快递。

3. 进程的注意事项

  • 一个bash当中,终端终只能有一个前台进程。
    在这里插入图片描述
  • Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
    在这里插入图片描述
  • Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生的信号。
    在这里插入图片描述
  • 前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步Asynchronous)的。
    在这里插入图片描述
    在这里插入图片描述

4. 信号概念

信号是进程之间事件异步通知的一种方式,属于软中断。
在这里插入图片描述

5. 用kill -l命令可以察看系统定义的信号列表

在这里插入图片描述

  • 每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定 义 #defineSIGINT 2。
  • 编号34以上的是实时信号,本章只讨论编号34以下的信号,不讨论实时信号。这些信号各自在什么条件下产生,默认的处理动作是什么,在signal(7)中都有详细说明: man 7 signal。
    在这里插入图片描述

6. 信号处理常见方式概览

  • (sigaction函数稍后详细介绍),可选的处理动作有以下三种:
  • 忽略此信号。
  • 执行该信号的默认处理动作。
  • 提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉(Catch)一个信号。

二、信号产生

代码如下(示例):

1. 通过终端按键产生信号

在这里插入图片描述
SIGINT的默认处理动作是终止进程,SIGQUIT的默认处理动作是终止进程并且Core Dump,现在我们来验证一下。

  • Core Dump

首先解释什么是Core Dump。当一个进程要异常终止时,可以选择把进程的用户空间内存数据全部 保存到磁盘上,文件名通常是core,这叫做Core Dump。进程异常终止通常是因为有Bug,比如非法内存访问导致段错误,事后可以用调试器检查core文件以查清错误原因,这叫做Post-mortem Debug(事后调试)。一个进程允许产生多大的core文件取决于进程的Resource Limit(这个信息保存 在PCB中)。默认是不允许产生core文件的,因为core文件中可能包含用户密码等敏感信息,不安全。在开发调试阶段可以用ulimit命令改变这个限制,允许产生core文件。
首先用ulimit命令改变Shell进程的Resource Limit,允许core文件最大为1024K: $ ulimit -c 1024
在这里插入图片描述

     1	#include<iostream>
     2	int main()
     3	{
     4		std::cout<<"hhh----Core Dump"<<std::endl;
     5		while(1);
     6		return 0;
     7	}

在这里插入图片描述
ulimit命令改变了Shell进程的Resource Limit,test进程的PCB由Shell进程复制而来,所以也具 有和Shell进程相同的Resource Limit值,这样就可以产生Core Dump了。 使用core文件:
在这里插入图片描述
在这里插入图片描述

2. 调用系统函数向进程发信号

首先在后台执行死循环程序,然后用kill命令给它发SIGSEGV信号。
在这里插入图片描述

  • 2741是test进程的进程id。之所以要再次回车才显示 Segmentation fault ,是因为在2741进程终止掉 之前已经回到了Shell提示符等待用户输入下一条命令,Shell不希望Segmentation fault信息和用 户的输入交错在一起,所以等用户输入命令之后才显示。
  • 指定发送某种信号的kill命令可以有多种写法,上面的命令还可以写成 kill -SIGSEGV 2741 或 kill -11 2741 , 11是信号SIGSEGV的编号。以往遇 到的段错误都是由非法内存访问产生的,而这个程序本身没错,给它发SIGSEGV也能产生段错误。

kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定的信号。
在这里插入图片描述

     1	#include<iostream>
     2	#include<stdlib.h>
     3	#include<signal.h>
     4	
     5	
     6	int main(int argc,char* argv[])
     7	{
     8	    if(argc==3)
     9	    {
    10	        kill(atoi(argv[1]),atoi(argv[2]));
    11	    }
    12	    return 0;
    13	}

在这里插入图片描述
raise函数可以给当前进程发送指定的信号(自己给自己发信号)。
在这里插入图片描述

     1	#include<iostream>
     2	#include<stdlib.h>
     3	#include<signal.h>
     4	#include<unistd.h>
     5	void handler(int signo)
     6	{
     7	    std::cout<<"catch a signal:"<<signo<<std::endl;
     8	}
     9	int main(int argc,char* argv[])
    10	{
    11	    signal(9,handler);//捕捉信号
    12	    while(1)
    13	    {
    14	        sleep(1);
    15	        raise(9);
    16	    }
    17	    return 0;
    18	}

在这里插入图片描述
其他信号可以捕捉例如2号:

     1	#include<iostream>
     2	#include<stdlib.h>
     3	#include<signal.h>
     4	#include<unistd.h>
     5	void handler(int signo)
     6	{
     7	    std::cout<<"catch a signal:"<<signo<<std::endl;
     8	}
     9	int main(int argc,char* argv[])
    10	{
    11	    signal(2,handler);//捕捉信号
    12	    while(1)
    13	    {
    14	        sleep(1);
    15	        raise(2);
    16	    }
    17	    return 0;
    18	}

在这里插入图片描述
abort函数使当前进程接收到信号而异常终止。

#include <stdlib.h>
void abort(void);
就像exit函数一样,abort函数总是会成功的,所以没有返回值。

在这里插入图片描述
在这里插入图片描述

     1	#include<iostream>
     2	#include<stdlib.h>
     3	#include<signal.h>
     4	#include<unistd.h>
     5	void handler(int signo)
     6	{
     7	    std::cout<<"catch a signal:"<<signo<<std::endl;
     8	}
     9	int main(int argc,char* argv[])
    10	{
    11	    signal(6,handler);//捕捉信号
    12	    while(1)
    13	    {
    14	        sleep(1);
    15	        abort();
    16	    }
    17	    return 0;
    18	}

在这里插入图片描述

3. 由软件条件产生信号

在这里插入图片描述
SIGPIPE是一种由软件条件产生的信号,在“管道”中已经介绍过了。本节主要介绍alarm函数 和SIGALRM信号。
在这里插入图片描述

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。打个比方,某人要小睡一觉,设定闹钟为30分钟之后响,20分钟后被人吵醒了,还想多睡一会儿,于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就是10分钟。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数(自己验证一下?)

     1	#include<iostream>
     2	#include<stdlib.h>
     3	#include<signal.h>
     4	#include<unistd.h>
     5	
     6	int main(int argc,char* argv[])
     7	{
     8	    int count=0;
     9	    alarm(1);
    10	    while(1)
    11	    {
    12	        std::cout<<"count:"<<count++<<std::endl;
    13	    }
    14	    return 0;
    15	}

在这里插入图片描述
由图知道1S中count打印了2W次左右,这个程序的作用是1秒钟之内不停地数数,1秒钟到了就被SIGALRM信号终止。

思考:为啥打印出来只有2W。换种代码试下

     1	#include<iostream>
     2	#include<stdlib.h>
     3	#include<signal.h>
     4	#include<unistd.h>
     5	int count=0;
     6	void handler(int signo)
     7	{
     8	    std::cout<<"count:"<<count<<std::endl;
     9	    exit(1);
    10	}
    11	int main(int argc,char* argv[])
    12	{
    13	    signal(14,handler);
    14	    alarm(1);
    15	    while(1)
    16	    {
    17	        count++;
    18	    }
    19	    return 0;
    20	}

这里的结果变成了4亿,为什么?
因为上面改的程序不往IO上面去输出,往IO上输出会影响效率。
在这里插入图片描述

4. 硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释 为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

1.信号捕捉初识

     1	#include<iostream>
     2	#include<signal.h>
     3	void handler(int signo)
     4	{
     5	    std::cout<<"catch a signal:"<<signo<<std::endl;
     6	}
     7	int main()
     8	{
     9	    signal(2,handler);//捕捉2号信号
    10	    while(1);
    11	    return 0;
    12	}

在这里插入图片描述

2.模拟一下野指针异常

     1	#include<iostream>
     2	#include<signal.h>
     3	#include<unistd.h>
     4	void handler(int signo)
     5	{
     6	    std::cout<<"catch a signal:"<<signo<<std::endl;
     7	}
     8	int main()
     9	{
    10	    signal(2,handler);//捕捉2号信号
    11	    sleep(1);
    12	    int* p=NULL;
    13	    *p=100;
    14	    while(1);
    15	    return 0;
    16	}

在这里插入图片描述
段错误是11号信号:
在这里插入图片描述
所以这里可以捕捉11号信号:

     1	#include<iostream>
     2	#include<signal.h>
     3	#include<unistd.h>
     4	void handler(int signo)
     5	{
     6	    std::cout<<"catch a signal:"<<signo<<std::endl;
     7	}
     8	int main()
     9	{
    10	    signal(11,handler);//捕捉2号信号
    11	    sleep(1);
    12	    int* p=NULL;
    13	    *p=100;
    14	    while(1);
    15	    sleep(1);
    16	    return 0;
    17	}

在这里插入图片描述
由此可以确认,我们在C/C++当中除零,内存越界等异常,在系统层面上,是被当成信号处理的。

  • 总结思考一下:

  • 上面所说的所有信号产生,最终都要有OS来进行执行,为什么?OS是进程的管理者。

  • 信号的处理是否是立即处理的?在合适的时候。

  • 信号如果不是被立即处理,那么信号是否需要暂时被进程记录下来?记录在哪里最合适呢?
    在这里插入图片描述

  • 一个进程在没有收到信号的时候,能否能知道,自己应该对合法信号作何处理呢?

  • 如何理解OS向进程发送信号?能否描述一下完整的发送处理过程? 位图保存了1-31的信号。
    在这里插入图片描述
    产生了信号,所以信号都必须经过操作系统之手发送给进程。
    在这里插入图片描述


总结

以上就是今天要讲的内容,本文仅仅简单介绍了Linux进程间信号前半部分的使用,而信号让我们知道C/C++当中除零,内存越界等异常,在系统层面上,是被当成信号处理的。而后半部分中阻塞信号和捕捉信号等在下一篇文章提及,希望大家多多支持!另外如果上述有任何问题,请懂哥指教,不过没关系,主要是自己能坚持,更希望有一起学习的同学可以帮我指正,但是如果可以请温柔一点跟我讲,爱与和平是永远的主题,爱各位了。
在这里插入图片描述

以上是关于Linux从青铜到王者第十一篇:Linux进程间信号第一篇的主要内容,如果未能解决你的问题,请参考以下文章

Linux从青铜到王者第二十一篇:Linux网络基础第三篇之数据链路层

Linux从青铜到王者第十四篇:Linux网络基础第一篇

Lua从青铜到王者基础篇第十一篇:Lua文件I/O

Linux从青铜到王者第十二篇:Linux进程间信号第二篇

Linux从青铜到王者第十篇:Linux进程间通信第二篇

Linux从青铜到王者第十三篇:Linux多线程四万字详解