[linux] 详解linux进程信号

妖狐艹你老母 2023-01-23 13:53 41阅读 0赞

### 目录 ###

*  1. 信号概念
 *  2. 信号的种类
 *  3. 信号的处理流程
 *  4. 信号的产生方式
 *   *  4.1 软件产生
     *  4.2 硬件产生
 *  5. 信号的注册
 *  6. 信号的注销
 *  7. 信号的处理方式
 *   *  7.1 信号的处理方式及基本概念
     *  7.2 信号自定义处理方式
 *  8. 信号的阻塞
 *   *  8.1 block位图
     *  8.2 接口函数设置阻塞状态
 *  9. volatile关键字

# 1. 信号概念 #

信号就是程序要执行某件事情之前发送的信号，通知进程要做什么事情，是一个**软件中断**，信号是进程之间事件异步通知的一种方式。  
  下面用一个具体的例子解释信号。在日常生活中有非常多种的信号，比如说在过马路时，红灯不通行，绿灯通行。这就是一个发送给行人与车辆的信号。  
  在linux种，写了一个程序，但是这个程序因为某种原因，没有办法正常结束了，可以通过 `ctrl+c` 强制的结束掉这个进程。在这个过程中，使用`ctrl+c`产生了一个硬件的中断，给进程发送了一个结束的信号，进程接收到这个信号并且立即处理这个信号，结束进程。

# 2. 信号的种类 #

在linux中，共有62种信号可以通过 `kill -l`命令进行查看.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center]  
**1. 非可靠信号(非实时信号)**  
在信号分类中，`1-31`号信号被称为非可靠信号，即受到上述信号后，进程不会立即处理该信号，**信号有可能会丢失**。

**2. 可靠信号(实时信号)**  
`34-64`号信号被称为可靠信号，**信号绝对不会丢失**。

# 3. 信号的处理流程 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 1]

>  *  在信号处理信号时，当处理完某些功能，进入内核态后，处理完异常之后，一定会调用`do_signal`函数，在函数中会检测当前有没有要处理的信号，如果有则判断是否执行默认处理，还是自定义的处理方式，处理完成后才会返回用户态，如果没有则直接返回用户态。
>  *  **执行流从内核态切换到用户态之前一定会调用`do_signal`函数处理信号**
>  *  从用户态切换到内核态时，是调用了系统调用函数，或者进程异常

# 4. 信号的产生方式 #

## 4.1 软件产生 ##

**1. 命令产生**  
`kill`命令: 可以通过`kill -num`的方式向进程中发送指定的信号.  
![在这里插入图片描述][20210715142558978.PNG_pic_center]  
![在这里插入图片描述][20210715142606625.PNG_pic_center]

**2. 函数产生**

int kill(pid_t pid, int sig);
    // 参数: pid要发送信号的进程pid
    // sig发送信号的序号
    /
    int raise(int sig);
    // 作用：向自身发送信号，内部封装了kill函数
    /
    unsigned int alarm(unsigned int seconds);
    // 作用：参数传递一个秒数，在事件到达之后发送一个SIGALRM信号

**代码测试**

#include <signal.h> 
    #include <stdio.h> 
    #include <unistd.h> 
        
    int main()    
    {     
        //kill(getpid(), 2); 
        raise(2);              
                               
        // 如果没有打印这一句 说明上述语句没有发送成功 
        printf("hello");       
                               
        return 0;              
    }

![在这里插入图片描述][20210715143500735.PNG_pic_center]

## 4.2 硬件产生 ##

`ctrl+c`: 发送的为2号信号即`SIGINT`  
`ctrl+z`: 发送的为3号信号即`SIGQUIT`  
`ctrl+|`: 发送的为20号信号即`SIGSTP`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 2]

# 5. 信号的注册 #

信号的注册是通过改变signal位图中的比特位进行信号的注册。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 3]

> linux中信号的种类共有62个，但用于存储信号的变量只有2个long的长度，共128个字节，如果一个变量存储一个是远远不够的，所以采用 **位图** 的方式进行存储信号，数组中对应的每一位存储一个信号，有信号则置为1，无则保持为0。并且数组的每一位没有全部使用，含有预留位置。

并且`signalpending`结构体中含有一个`sigqueue队列`，信号接收到进行注册时，需要在sigqueue队列中添加结点

>  *  非可靠信号的注册  
>     第一次: 将信号对应的比特位置为1，在sigqueue队列中添加sigqueue结点  
>     第二次: 只会将信号对应的比特位从1改为1，不会添加sigqueue结点
>  *  可靠信号的注册  
>     第一次: 将信号对应的比特位置为1，并且在sigqueue队列中添加sigqueue结点  
>     第二次: 将信号对应的比特位从1改为1，并且还会在sigqueue队列中添加sigqueue结点

# 6. 信号的注销 #

**1. 非可靠信号的注销**  
  将信号对应在signal位图中的比特位置为0，并且将sigqueue结点从sigqueue队列当中进行出队操作。

**2. 可靠信号的注销**  
  1.将可靠信号对应的sigqueue节点从sigqueue队列中进行出队操作。  
  2.判断sigqueue队列当中是否还有当前可靠信号的sigqueue节点。如果没有，则将signal位图当中可靠信号对应的比特位置为0。如果有，则不会将signal位图当中的可靠信号对应的比特位置为0。

# 7. 信号的处理方式 #

## 7.1 信号的处理方式及基本概念 ##

默认处理方式：`SIGDFL`，在操作系统内核有对该信号的默认处理动作。  
忽略处理方式：`SIGCHILD`，子进程在退出时会给父进程发送一个SIGCHILD信号，但是父进程不关心这个信号  
自定义处理方式：更改信号的处理方式。

>  *  实际执行信号的处理动作称为信号递达(Delivery)
>  *  信号从产生到递达之间的状态,称为信号未决(Pending)。
>  *  进程可以选择阻塞 (Block )某个信号。被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
>  *  注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

## 7.2 信号自定义处理方式 ##

**1. 接口函数**

函数一

sighandler_t signal(int signum, sighandler_t handler);
    // 作用：更改信号的处理方式
    // 参数: signum 待自定义处理函数的信号
    // handler: 函数指针，接收一个函数地址，该函数的返回值是void
    // 参数为int，当进程受到某个信号时，就会触发调用该函数，
    // 并将该信号的值，传递给回调函数

#include <stdio.h> 
    #include <unistd.h> 
    #include <signal.h> 
        
    void sigcb(int signo)    
    {     
        printf("signo: %d\n", signo);    
    }    
                          
    int main()                                                  
    {           
    	// 当收到一下三种信号时，会调用回调函数输出进程号 
        signal(SIGINT, sigcb);    
        signal(SIGTSTP, sigcb);                          
        signal(SIGQUIT, sigcb);             
                                 
        while(1)                                
        {     
            sleep(1);                                                      
        }                                                                
                                                                  
        return 0;    
    }

![在这里插入图片描述][20210715160831531.PNG_pic_center]

函数二

int sigaction(int signum, const struct sigaction *act,
                  struct sigaction *oldact);
    // 参数: signum 待自定义处理信号
    // act 想要将信号更改为什么处理动作，是一个结构体变量:
    // 参数1: void(*sa_handler)(int); 默认保存信号处理函数的函数指针
    // 参数2: void(*sa_sigaction)(int, siginfo_t*,void*)
    // 参数3: int sa_flags; 与上一个参数连用，一般不使用
    // 参数4: sigset_t sa_mask 当正在处理信号时，会将注册的信号先放入该变量中过度,
    // 当处理完该信号后，会将刚才注册的信号放入signal位图中
    // 参数5: void(*sa_restorer)(void); 预留信息
    // oldact：信号之前的处理动作

#include <stdio.h> 
    #include <signal.h> 
    #include <unistd.h> 
        
    void sigcb(int signo)    
    {     
        printf("signo:%d\n", signo);    
    }    
        
    int main()    
    {     
        struct sigaction act;    
        act.sa_handler = sigcb;    
        act.sa_flags = 0;    
        sigemptyset(&act.sa_mask); // 将mask中的比特位全部置为0 
        
        // 拦截SIGINT信号
        sigaction(SIGINT, &act, NULL);    
        
        while (1)    
        {     
            sleep(1);    
        }    
        
        return 0;    
    }

![在这里插入图片描述][20210715162022228.PNG_pic_center]

# 8. 信号的阻塞 #

当准备处理信号时，会判断当前信号是否为阻塞，如果该信号为阻塞，则暂时不会处理该信号。

## 8.1 block位图 ##

该位图的结构与signal位图的类型相同，处理信号之前，会先查看block位图当中对应信号为的位图值是否为1，如果为1，则暂时不会去处理该信号。

## 8.2 接口函数设置阻塞状态 ##

int sigprocmask(int how, const sigset_t* set, sigset_t* oldset);
    // 作用：设置信号为阻塞状态
    // 参数：
    // how: 告诉sigprocmask函数以什么方式进行工作
    // SIG_BLOCK: 设置某个信号为阻塞状态 block(new) = block(old) | set
    // SIG_UNBLOCK: 解除信号为阻塞状态 block(new) = block(old) (~set)
    // SIG_SETMASK: 替换原来的block位图 block(new) = set
    // set: 要修改新的位图
    // oldset: 在没有更改之前老的block位图

**代码验证可靠信号与非可靠信号的阻塞**

#include <signal.h> 
    #include <stdio.h> 
    #include <unistd.h> 
        
    void signalcallback(int signo)    
    {     
        printf("signo: %d\n", signo);    
    }    
        
    int main()    
    { 
        // 更改2 40号信号的处理方式
        // 2: 非可靠信号
        // 40: 可靠信号
        signal(2, signalcallback);                                                                                                                                           
        signal(40, signalcallback);
                         
        // 阻塞所有信号 
        sigset_t set;                                  
        sigset_t oldblock;                         
        sigfillset(&set); // 将set中所有比特位置为1 
                                                  
        sigprocmask(SIG_SETMASK, &set, &oldblock);
                  
      	// 程序运行后，不输入内容会发生阻塞 
        getchar();                                    
                                                  
        sigprocmask(SIG_SETMASK, &oldblock, NULL);
                 
        return 0;
    }

启动两个窗口，一个窗口进行进程阻塞时的等待，另外一个窗口发送信号。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 4]

![在这里插入图片描述][20210715170100273.PNG_pic_center]  
**现象总结**

>  *  信号的阻塞并不会干扰信号的注册
>  *  可靠信号受到几次处理几次，非可靠信号收到多次只处理一次，非可靠信号可能会丢失
>  *  先处理可靠信号，最后处理非可靠信号，按照队列出队的顺序进行处理
>  *  4、9、19号信号不能被阻塞，保证程序退出的条件

# 9. volatile关键字 #

先看一段代码

#include <stdio.h> 
    #include <unistd.h>
    #include <signal.h>
    
    int g_v = 1;
    
    void signalcallback(int signo)
    { 
        g_v = 0;
        printf("signo: %d\n", signo);
    }
    
    int main()
    { 
        signal(2, signalcallback);
    
        while(g_v)                                                                              
        {                                                                                        
                                                                                                
        }                                                                                       
                                                                                                
        return 0;                                                                               
    }

> 在这段代码中，我们阻塞了2号信号，在回调函数内部，修改了`g_v`这个全局变量的值，main函数中的while循环依赖与这个值的运行去运行，当发送二号信号之后，在回调函数内部，修改`g_v`之后，程序应该会停止运行

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 5]

> 上图中可以看出，虽然进入了回调函数，并且修改了全局变量的值，但并没有跳出循环。  
> 因为该程序的优化等级较高，效率较快，所以程序会从寄存器中将值取出，我们更改的值存在内存中，内存中的值发生了更改但是寄存器中的值没有发生更改，所以程序没有结束。  
> 如果在全局变量前加上`volatile`关键字，就会禁止程序从寄存器中取值，保持内存的可见性。

#include <stdio.h> 
    #include <unistd.h> 
    #include <signal.h> 
        
    // 进程程序在寄存器中取值，而是从内存中取值，保持内存可见性 
    volatile int g_v = 1;                       
                                                
    void signalcallback(int signo)              
    {                                            
        g_v = 0;                                
        printf("signo: %d\n", signo);           
    }                                           
                                                
    int main()                                  
    {                                            
        signal(2, signalcallback);              
                                                                                                
        while(g_v)                                                                              
        {                                                                                        
                                                                                                
        }                                                                                       
                                                                                                
        return 0;                                                                               
    }

![在这里插入图片描述][20210715171948232.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221004/619b011891574c29be0d09270077b4fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221004/fe3b0efd9e9e41338624ea1b32e60eb2.png
[20210715142558978.PNG_pic_center]: /images/20221004/36e6754fb09e489c9a0cc99b44f67342.png
[20210715142606625.PNG_pic_center]: /images/20221004/6ef902440ec24e74a839fcba39d2b0bf.png
[20210715143500735.PNG_pic_center]: /images/20221004/44ad14f515604106b65b379304f758c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221004/5f4fa45c2f944ddbad433892c5d4d5ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221004/3aa4128a36524d9384e37af8d5af12e6.png
[20210715160831531.PNG_pic_center]: /images/20221004/fc3fd6f4fcd5473ebad59965e146001b.png
[20210715162022228.PNG_pic_center]: /images/20221004/4ac7208a90dc41b2811cb248cb94854c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221004/e47ad4b98f4f4df89ee1ff1ce957c46d.png
[20210715170100273.PNG_pic_center]: /images/20221004/624b1f4961604fc3bc1c75557c6ef264.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221004/c82c674ee8fd427eac8ae1ffc7550105.png
[20210715171948232.png_pic_center]: /images/20221004/e9d4470e424a46a8ab5027d63856c388.png