【Linux】进程信号

电玩女神 2024-03-16 15:57 13阅读 0赞

**目录**

【1】Linux下查看信号大全的方式

【2】从生活角度的信号

【3】技术应用角度的信号

【4】信号处理常见的方式

【5】产生信号

【5.1】键盘输入

【5.2】系统调用

【5.3】硬件异常产生信号

【5.4】软件条件产生信号

【5.5】进程退出时的核心转储问题

【6】阻塞信号

【6.1】信号其他相关常见概念

【6.2】在内核中的表示

【7】信号捕捉

【8】信号集操作函数

【9】捕捉方法signal与sigaction

【10】可重入函数

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

## 【1】Linux下查看信号大全的方式 ##

[shaxiang@VM-8-14-centos ~]$ kill -l                // 命令
     1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL     5) SIGTRAP
     6) SIGABRT     7) SIGBUS     8) SIGFPE     9) SIGKILL    10) SIGUSR1
    11) SIGSEGV    12) SIGUSR2    13) SIGPIPE    14) SIGALRM    15) SIGTERM
    16) SIGSTKFLT    17) SIGCHLD    18) SIGCONT    19) SIGSTOP    20) SIGTSTP
    21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) SIGXCPU    25) SIGXFSZ
    26) SIGVTALRM    27) SIGPROF    28) SIGWINCH    29) SIGIO    30) SIGPWR
    31) SIGSYS    34) SIGRTMIN    35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3
    38) SIGRTMIN+4    39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    42) SIGRTMIN+8
    43) SIGRTMIN+9    44) SIGRTMIN+10    45) SIGRTMIN+11    46) SIGRTMIN+12    47) SIGRTMIN+13
    48) SIGRTMIN+14    49) SIGRTMIN+15    50) SIGRTMAX-14    51) SIGRTMAX-13    52) SIGRTMAX-12
    53) SIGRTMAX-11    54) SIGRTMAX-10    55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7
    58) SIGRTMAX-6    59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    62) SIGRTMAX-2
    63) SIGRTMAX-1    64) SIGRTMAX

### 【2】从生活角度的信号 ###

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

**进程如何识别信号呢?**

进程是认识+动作，进程本身是程序员编写的属性和逻辑集合，程序员编写完成的，当进程收到信号的时候，进程可能正在执行更重要的代码，所以信号不一定会被立即处理，进程本身必须要有对于信号的保存能力，进程在处理信号的时候，一般有三种动作(默认、自定义、忽略)【信号被捕捉】

### 【3】技术应用角度的信号 ###

1.  用户输入命令,在Shell下启动一个前台进程。
2.  用户按下Ctrl-C ,这个键盘输入产生一个硬件中断，被OS获取，解释成信号，发送给目标前台进程。
3.  前台进程因为收到信号，进而引起进程退出。

#include <iostream>
    #include <unistd.h>
    #include <sys/types.h>
    int main(){
        while(1){
            std::cout << "我是一个进程：pid->" << getpid() << std::endl;
            sleep(1);
        }
        return 0;
    }
    
    [shaxiang@VM-8-14-centos signel]$ ./mySignel 
    我是一个进程：pid->19269
    我是一个进程：pid->19269
    ^C

*  Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
 *  Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生的信号。
 *  前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步(Asynchronous)的。
 *  **ctrl + c 热键：本质就是一个组合键，由操作系统将 Ctrl + c 解释成为2号信号 2) SIGINT，为了解释这一句话，我们看下面代码：**

**认识 ctrl + c 的事件信息**

![c5f6c8eb6cee42e38832a92b6fec419e.png][]

**认识signal函数**

**实例代码：**

#include <iostream>
    #include <unistd.h>
    #include <signal.h>
    #include <sys/types.h>
    
    void handler(int sigNo){
        std::cout << "进程捕捉到了一个信号，信号编号是：" << sigNo << std::endl;
    }
    
    int main(){
        // 这里的signal函数调用，并不是handler函数的调用！
        // 仅仅是设置了2号信号的捕捉方法，并不代表该方法被调用了！
        // 一般这种方法不会执行，除非收到了对应的2号信号！
        signal(2, handler);
        while(1){
            std::cout << "我是一个进程：pid->" << getpid() << std::endl;
            sleep(1);
        }
        return 0;
    }
    
    // 执行结果：
    kill -2 26920    // 执行信号
    Ctrl + c         // 执行信号
    kill -9 26920    // 杀掉进程

## 【4】信号处理常见的方式 ##

(sigaction函数稍后详细介绍),可选的处理动作**有以下三种:**

*  忽略此信号。
 *  执行该信号的默认处理动作。
 *  提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉(Catch)一个信号。

## 【5】产生信号 ##

### 【5.1】键盘输入 ###

**键盘输入：**

*  CTRL + C -> | 发送2号信号
 *  CTRL + \\ -> | 发送3号信号

### 【5.2】系统调用 ###

**系统调用【kill】：**

kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定的信号。raise函数可以给当前进程发送指定的信号(自己给自己发信号)。

#include <signal.h>
    功能：可以给人以进程发信号
    原型
    int kill(pid_t pid, int signo);     
    返回值：成功返回0,错误返回-1

**写一个myKill测试程序：**

// Makefile文件 》》》》》》》》》》》》》》》》》》》》》》》》》
    .PHONY:all
    all:mySignel myTest
    
    myTest:myTest.cpp
        g++ -o $@ $^ -std=c++11
    
    mySignel:mySignel.cpp
        g++ -o $@ $^ -std=c++11
    
    .PHONY:clean
    clean: 
        rm -f mySignel myTest
        
    // mySignal.cpp文件》》》》》》》》》》》》》》》》》》》》》》》》》
    #include <iostream>
    #include <string>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    using namespace std;
    
    void Usage(const std::string &proc){
        std::cout << "\nUsage: " << proc << "pid sig\n" << std::endl;
    }
    
    int main(int argc, char* argv[]){
        // 检查输入
        if(argc != 3) {
            Usage(argv[0]);
            exit(-1);
        }
    
        // 数据处理
        int pid = atoi(argv[1]);
        int sig = atoi(argv[2]);
        // 系统调用
        int n = kill(pid, sig);
        if(n != 0){
            perror("kill");
        }
        return 0;
    }
    
    // myTest.cpp文件》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    #include <iostream>
    #include <unistd.h>
    #include <sys/types.h>
    
    int main(){
        while(true){
            std::cout << "我是一个进程：我的pid是：" << getpid() << std::endl;
            sleep(1);
        }
    }

![8c7ffe6c14bf47a588e4cf71166ab8dd.png][]

**系统调用【raise】：**

#include <signal.h>
    功能：给自己发信号
    原型
    int raise(int signo);
    返回值：成功返回0,错误返回-1

**写测试代码：**

#include <iostream>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    using namespace std;
    
    int main(int argc, char* argv[]){
        int cnt = 1;
        while(cnt <= 10){
            cout << "cnt: " << cnt++ << endl;
            if(cnt == 5)
                raise(9);   // kill(getpid(), 9);   // 让自己退出！
        }
    
        return 0;
    }

**系统调用【abort】：**

abort函数使当前进程接收到信号而异常终止。

#include <stdlib.h>
    功能：给自己发送指定的信号SIGABRT
    原型
    void abort(void);
    就像exit函数一样,abort函数总是会成功的,所以没有返回值。

**写测试代码：**

#include <iostream>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    using namespace std;
    
    int main(int argc, char* argv[]){
        int cnt = 1;
        while(cnt <= 10){
            cout << "cnt: " << cnt++ << endl;
            if(cnt == 5)
                // raise(9);   // kill(getpid(), 9);   // 让自己退出！
                abort(); // kill(getpid(), 6);   // 让自己退出！
        }
    
        return 0;
    }

**关于信号处理行为的理解：**有很多情况，进程收到大部分信号，默认处理动作都是终止进程。

**信号的意义：**信号的不同，代表不同的信号，但是对信号发生之后的处理动作可以一样！

### 【5.3】硬件异常产生信号 ###

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

**除0异常：**

#include <iostream>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    using namespace std;
    
    void tryCach(int sigNo){
        cout << "抓到SIGFPE异常信号: " << sigNo << endl;
        sleep(1);
    }
    
    int main(int argc, char* argv[]){
        // 注册信号
        signal(SIGFPE, tryCach);
        int i = 0;
        i /= 0;
        while(true){
            cout << "我是一个进程：" << endl;
        }
        return 0;
    }
    
    // 打印结果：
    [shaxiang@VM-8-14-centos signel]$ ./mySignel 
    抓到SIGFPE异常信号: 8
    抓到SIGFPE异常信号: 8
    抓到SIGFPE异常信号: 8
    抓到SIGFPE异常信号: 8
    抓到SIGFPE异常信号: 8
    抓到SIGFPE异常信号: 8
     
    
    // 为什么会一直打印异常信号？
        受到信号不一定会引起进程退出，没有退出，有可能还会被调到，CPU内的寄存器只有一份，但是寄存器中的内容，
    属于上下文，没有能力或者动作修正这个问题，当进程被切换的时候，就有无数次状态寄存器中的溢出标志为1，OS检测
    到溢出标志为1，所以就会抛出信号。

**野指针异常：**

### 【5.4】软件条件产生信号 ###

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

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

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

**写测试代码：**

#include <iostream>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    using namespace std;
    
    int main(int argc, char* argv[]){
        // 统计1S，计算机执行++cnt多少次>
        alarm(1);
        
        int cnt = 0;
        while(true){
            cout << "cnt: " << cnt++ << endl;
        }
        return 0;
    }

**信号总结：**

*  上面所说的所有信号产生，最终都要有OS来进行执行，为什么？OS是进程的管理者
 *  信号的处理是否是立即处理的？在合适的时候
 *  信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？
 *  一个进程在没有收到信号的时候，能否能知道，自己应该对合法信号作何处理呢？
 *  如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？

### 【5.5】进程退出时的核心转储问题 ###

在云服务器上，默认如果进程是core退出的，我们暂时看不到明显的现象，如果想要看到：需要使用命令

ulimit -a
    ulimit -c 1024

![f6f86dfaacb2469eb0024510ff89e761.png][]

**核心转储就是：**当进程出现异常的时候，我们将进程在对应时刻，在内存中的有效数据转储到磁盘中 - 称为核心转储。

![92b6da9320b2448f98fadf8ded86d139.png][]

**那为什么要有核心转储呢？**

![6c8ff557f13c4c20af46c37c248ef2df.png][]

**经过测试发现：**Core的信号是带有核心转储的，Term的信号是不带核心转储的。

![e8c6a7abd52446959eb6b986b4acab48.png][]

## 【6】阻塞信号 ##

### 【6.1】信号其他相关常见概念 ###

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

###  ###

### 【6.2】在内核中的表示 ###

![5e516645ad924f91ba6dce9c176d45b4.png][]

每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。

SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。

SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。本章不讨论实时信号。

## 【7】信号捕捉 ##

信号产生的时候，不会被立即处理，而是在合适的时候**（合适：从内核态返回用户态的时候，进行处理）**

**内核态和用户态：**

![32ead4295db64f60aa9387580f4e189a.png][]

![9ab7db92244346a3bbee1a6792bb3e04.png][]

![093872dcca0b4294bfc419a6f212a332.png][]

## 【8】信号集操作函数 ##

sigset\_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储这些bit则依赖于系统实现,从使用者的角度是不必关心的,使用者只能调用以下函数来操作sigset\_ t变量,而不应该对它的内部数据做任何解释,比如用printf直接打印sigset\_t变量是没有意义的。

#include <signal.h>
    int sigemptyset(sigset_t *set);                            // 信号全清零
    int sigfillset(sigset_t *set);                             // 信号全置一
    int sigaddset (sigset_t *set, int signo);                  // 信号添加到集合里
    int sigdelset(sigset_t *set, int signo);                   // 集合中删除信号
    int sigismember（const sigset_t *set, int signo);          // 判断信号是否在集合中
    
    // 这四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,
    // 用于判断一个信号集的有效信号中是否包含某种 信号,若包含则返回1,不包含则返回0,出错返回-1。

*  函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号。
 *  函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系统支持的所有信号。
 *  注意,在使用sigset\_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset\_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

**sigprocmask函数**

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

#include <signal.h>
    int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
    返回值:若成功则为0,若出错则为-1

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则 更改进程的信号屏蔽字,参数how指示如何更改。如果oset和set都是非空指针,则先将原来的信号 屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。

<table> 
 <tbody> 
  <tr> 
   <td> <p>SIG_BLOCK</p> </td> 
   <td> <p>set包含了我们希望添加到当前信号字的信号，相当于mask=mask | set</p> </td> 
  </tr> 
  <tr> 
   <td> <p>SIG_UNBLOCK</p> </td> 
   <td> <p>set包含了我们希望从当前信号屏蔽中解除阻塞信号，相当于make=make&amp;~set</p> </td> 
  </tr> 
  <tr> 
   <td> <p>SIG_SETMASK</p> </td> 
   <td> <p>设置当前信号屏蔽字为set所指向的值，相当于make=set</p> </td> 
  </tr> 
 </tbody> 
</table>

如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达。

**sigpending函数**

#include <signal.h>
    sigpending
    读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。 下面用刚学的几个函数做个实验。程
    序如下:

![9c229c9bba87473286fa8322ebf2b4ce.png][]

**第一个测试信号集函数：**

// 代码背景：
    // 1、默认情况下：我们的所有信号都是不被阻塞的！
    // 2、默认情况下：如果一个信号被屏蔽了，该信号不会被抵达！
    
    #include <iostream>
    #include <vector>
    #include <signal.h>
    #include <unistd.h>
    #define SIGNAL 2
    #define MAX_SIGNUM 31
    static std::vector<int> v = {2, 3};
    static void show_pending(sigset_t &pending){
        for(int signo = MAX_SIGNUM; signo >= 1 ; signo--){
            if(sigismember(&pending, signo)){
                std::cout << "1";
            }
            else
            {
                std::cout << "0";
            }
        }
        std::cout << std::endl;
    }
    
    void msg(int sigNo){
        std::cout << sigNo << "信号已经被抵达" << std::endl;
        std::cout << "恢复对信号的屏蔽，不屏蔽任何信号！" << std::endl;
    }
    
    int main(){
        // 捕捉信号
        for(auto sigNo : v){
            signal(sigNo, msg);
        }
    
        // 1、先尝试屏蔽某一个信号
        sigset_t block, oblock, pending;
        // 1.1、初始化
        sigemptyset(&block);
        sigemptyset(&oblock);
        sigemptyset(&pending);
        // 1.2、添加要屏蔽的信号
        sigaddset(&block, SIGNAL);
        // 1.3、开始屏蔽信号(设置进内核(进程))
        sigprocmask(SIG_SETMASK, &block, &oblock);
    
        // 2、遍历打印所有的pengding信号集
        int cnt = 10;
        while(true){
            // 2.1 初始化
            sigemptyset(&pending);
            // 2.2 获取它
            sigpending(&pending);
            // 2.3 打印它
            show_pending(pending);
            // 2.4 慢一点
            sleep(1);
    
            // 2.5将屏蔽的信号恢复
            if(cnt-- == 0){
                cnt = 10;
                sigprocmask(SIG_SETMASK, &oblock, &block);  // 一旦对特定信号解除屏蔽，一边OS要至少立马抵达一个信号！
            
                // 继续屏蔽信号(设置进内核(进程))
                sigprocmask(SIG_SETMASK, &block, &oblock);
            }
        }
    
        return 0;
    }

![fe8ef2a56e2f4748bb1ca3837614b825.png][]

## 【9】捕捉方法signal与sigaction ##

#include <signal.h>
    功能：信号- ANSI C信号处理
    原型
    
    
    typedef void (*sighandler_t)(int);
    
    sighandler_t signal(int signum, sighandler_t handler);
    参数：
        signum：事件编号
        handler：回调函数handler
    返回值：
        返回信号处理程序的前一个值，或者在错误时返回SIG_ERR。如果发生错误，则设置errno来指示原因。
    
    #include <signal.h>
    功能：信号- ANSI C信号处理
    原型
    int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);
    参数：
        signo：事件编号
        *act：结构体指针
            struct sigaction {
                void     (*sa_handler)(int);                            // 函数指针
                void     (*sa_sigaction)(int, siginfo_t *, void *);     // nullptr 与 普通信号无关
                sigset_t   sa_mask;                                     
                int        sa_flags;                                    // 0
                void     (*sa_restorer)(void);                          // nullptr 与 普通信号无关
            };
        *oact：
    返回值：
        成功返回0，失败返回-1，如果发生错误，则设置errno来指示原因。

**测试信号集程序：**

// Makefile 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    mySignal:mySignal.cpp
        g++ -o $@ $^ -std=c++11
    .PHONY:clean
    clean:
        rm -f mySignal
    
    // mySignal.cpp 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
    #include <iostream>
    #include <cstdlib>
    #include <unistd.h>
    #include <signal.h>
    void Count(int cnt){
        while(cnt--){
            printf("cnt:%2d\r", cnt);
            fflush(stdout);
            sleep(1);
        }
        printf("\n");
    }
    
    void handler(int signo){
        std::cout << "get a signo: " << "正在处理中....." << std::endl;
        Count(20);
    }
    
    int main(){
        // 定义sigaction指针参数的结构体变量.
        struct sigaction act, oldact;
        act.sa_handler = handler;
        act.sa_flags = 0;
        sigemptyset(&act.sa_mask);
        // 调用测试函数
        sigaction(SIGINT, &act, &oldact);
    
        while(true) sleep(1);
        return 0;
    }
    // 当我们进程正在抵达某一个信号期间，同类型信号无法被抵达！
    // 当当前信号正在被捕捉，系统会自动将当前信号假如到进程的信号屏蔽字block中！
    // 当信号完成捕捉动作，系统又会自动解除对对该信号的屏蔽！
    // (对该信号的屏蔽)->一般一个信号被解除屏蔽的时候，会自动进行抵达当前屏蔽信号，如果该信号已经被pending的话，没有就不做任何动作
    // 我们在进行处理信号的原则是串行的处理同类型的信号，不允许递归！
    // 演示结果如下：

![a5539e22fe3842e3a55e507cbd8396fc.png][]

**sa\_mask特殊含义：**

#include <iostream>
    #include <cstdlib>
    #include <unistd.h>
    #include <signal.h>
    
    void Count(int cnt){
        while(cnt--){
            printf("cnt:%2d\r", cnt);
            fflush(stdout);
            sleep(1);
        }
        printf("\n");
    }
    
    void handler(int signo){
        std::cout << "get a signo: " << "正在处理中....." << std::endl;
        Count(20);
    }
    
    int main(){
        // 定义sigaction指针参数的结构体变量.
        struct sigaction act, oldact;
        act.sa_handler = handler;
        act.sa_flags = 0;
        sigemptyset(&act.sa_mask);  // 当我们在处理某种信号的时候，我们也想顺便屏蔽其他信号，就可以添加到这个sa_mask中！  
        
        sigaddset(&act.sa_mask, SIGQUIT);   // 处理2号信号的时候，3号信号也会被屏蔽！
        // 调用测试函数
        sigaction(SIGINT, &act, &oldact);
    
        while(true) sleep(1);
        return 0;
    }

## 【10】可重入函数 ##

main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的 时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler函数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的 两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只有一个节点真正插入链表中了。

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为 不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant) 函数。想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

**如果一个函数符合以下条件之一则是不可重入的:**

*  调用了malloc或free,因为malloc也是用全局链表来管理堆的。
 *  调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

**结论：**

一般而言，我们认为：main的执行流和信号的执行流是两个执行流！如果在main中，和在handler中，该函数被重复进入，出现问题-该函数insert不可重入函数，

如果在main中和在handler中，该函数被重复进入，没有出现问题，-gai'han'sh

[c5f6c8eb6cee42e38832a92b6fec419e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b47897839d014ce698346f59d62c44f0.png
[8c7ffe6c14bf47a588e4cf71166ab8dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/17be5517588b4a70870e846bd3da7e39.png
[f6f86dfaacb2469eb0024510ff89e761.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/918ba343569a4289b560ac074b6c6217.png
[92b6da9320b2448f98fadf8ded86d139.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/dc8449413f5c483ab83ce64f7930747c.png
[6c8ff557f13c4c20af46c37c248ef2df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/9dfc8224448147d0a9f63c69abc0f955.png
[e8c6a7abd52446959eb6b986b4acab48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d63c475363984d6695406c133f0b3cd7.png
[5e516645ad924f91ba6dce9c176d45b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/bb0a85fd5ef943d0a485d55a8d9680a9.png
[32ead4295db64f60aa9387580f4e189a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/61d39d3e796b4bed96e418428f644e07.png
[9ab7db92244346a3bbee1a6792bb3e04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2243cbcca56c48f39aa914512754e2bb.png
[093872dcca0b4294bfc419a6f212a332.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8bdfecd1ff884f879f8668c80b0a0efc.png
[9c229c9bba87473286fa8322ebf2b4ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/9b1a3b9add0345ef9fe8097e6ed7682f.png
[fe8ef2a56e2f4748bb1ca3837614b825.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f8ddb98fbf5044a58d4846545b4a747c.png
[a5539e22fe3842e3a55e507cbd8396fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2caff62989d449cc924d0ca20b38025e.png