【Linux】第三十九站：可重入函数、volatile、SIGCHLD信号

大家好，欢迎来到IT知识分享网。

一、可重入函数

如下图所示，当我们进行链表的头插的时候，我们刚刚执行完第一条语句的时候，突然收到一个信号，然后我们这个信号的自定义捕捉方法中，正好还有一个头插，于是这个执行流再次进入这个函数中。执行完毕以后，返回到原来的执行流中继续运行。

这种现象就是函数被重入了

就会导致下面的现象。

我们可以看到，这个node2结点丢失了，最终导致了内存泄漏了

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

上面的现象是这样的：

1. insert函数被mainh和handler执行流重复进入
2. 导致了结点丢失，内存泄漏

所以我们有了如下定义：

如果一个函数，被重复进入的情况下，出错了，或者可能出错。

我们就要把这个函数叫做不可重入函数

否则叫做可重入函数

目前我们用到的大部分函数都是不可重入的！

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

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

二、volatile

我们先看一下下面的代码

#include <iostream> #include <unistd.h> #include <signal.h> #include <cstring> using namespace std; int flag = 0; void handler(int signo) { 
    cout << "catch a signal: " << signo <<endl; flag = 1; } int main() { 
    signal(2, handler); while(!flag); cout << "process quit normal" << endl; return 0; } 

最终我们的结果如下

一切都符合我们的预期

但是在极端情况下，由于main和handler属于两个执行流

编译器检测后发现这个flag没有发生过变化。检测的本质也是计算，逻辑运算，这里的逻辑反也是一种计算。

它会在优化条件下，flag变量可能被直接优化到CPU内的寄存器中。

如下所示，我们的g++可以通过带上O0~O3选项进行优化。后面的数字越大，优化级别越高

如下所示，我们发现，如果是O0,就相当于没有优化，可以正常结束。如果是O1的话，那么此时就无法用二号信号退出了。

如下所示，这是因为我们没有优化之前，CPU会不断的将内存中的数据放入到寄存器中。而我们使用2号信号修改了之后，也还是会不断的访存。所以这个flag会改变，所以就会跳出循环

而现在，我们优化了之后，这个变量第一次拿到寄存器之后，就不再访存了，因为这样可以提高效率，就直接用寄存器当中的数据，而我们使用信号改掉的只是内存当中的数据。所以这里的运算就一直为真了。所以就不会退出了。

这样因为优化，就如同形成了一个寄存器屏障。导致内存不可见了！

所以我们为了防止这样编译器的过度优化，我们可以给这个变量带上volatile关键字。

volatile int flag = 0; //防止编译器过度优化，保存内存的可见性 

所以我们代码改为如下

#include <iostream> #include <unistd.h> #include <signal.h> #include <cstring> using namespace std; volatile int flag = 0; void handler(int signo) { 
    cout << "catch a signal: " << signo <<endl; flag = 1; } int main() { 
    signal(2, handler); while(!flag); cout << "process quit normal" << endl; return 0; } 

三、SIGCHLD信号

我们之前用wait和waitpid函数清理僵尸进程,父进程可以阻塞等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式,父进程阻塞了就不 能处理自己的工作了;采用第二种方式,父进程在处理自己的工作的同时还要记得时不时地轮询一 下,程序实现复杂。

其实,子进程在终止时会给父进程发SIGCHLD（17号）信号,该信号的默认处理动作是忽略,父进程可以自 定义SIGCHLD信号的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程 终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可。

我们可以先捕捉一下17号信号，验证一下是否真的有17号信号

#include <iostream> #include <unistd.h> #include <signal.h> #include <cstring> using namespace std; void handler(int signo) { 
    cout << "I am process: " << getpid() << ", catch a signo: " << signo << endl; } int main() { 
    signal(17, handler); pid_t id = fork(); if(id == 0) { 
    while(true) { 
    cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl; sleep(1); break; } cout << "child quit...!!!" << endl; exit(0); } //father while(true) { 
    cout << "I am father process: " << getpid() << endl; sleep(1); } return 0; } 

运行结果为

所以利用这个17号信号，我们可以采用基于信号的方式进行等待

等待的好处：

1. 获取子进程的退出状态，释放子进程的僵尸
2. 虽然不知道父子谁先运行，但是我们清楚，一定是father最后退出

所以我们还是要调用wait/waitpid这样的接口。而且father必须保证自己是一直在运行的。

所以我们可以试着把子进程等待写入到信号捕捉函数中！

如下代码所示：

#include <iostream> #include <unistd.h> #include <signal.h> #include <cstring> #include <sys/wait.h> #include <sys/types.h> using namespace std; void handler(int signo) { 
    sleep(3); pid_t rid = waitpid(-1, nullptr, 0); cout << "I am process: " << getpid() << ", catch a signo: " << signo << "child process quit: " << rid << endl; } int main() { 
    signal(17, handler); pid_t id = fork(); if(id == 0) { 
    while(true) { 
    cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl; sleep(3); break; } cout << "child quit...!!!" << endl; exit(0); } //father while(true) { 
    cout << "I am father process: " << getpid() << endl; sleep(1); } return 0; } 

运行结果如下所示

如果有十个进程呢？？如果同时退出呢？？如果退出一半呢？？

如果是个进程同时退出，那么上面代码就有问题了，因为可能一个进程进程正在退出的时候，已经将这个信号屏蔽了，导致有很多进程无法被回收，全部都是僵尸进程了。

如下代码所示，我们在捕捉函数中循环等待，但是要主要加上非阻塞式。否则会一直卡在那里了。

#include <iostream> #include <unistd.h> #include <signal.h> #include <cstring> #include <time.h> #include <sys/wait.h> #include <sys/types.h> using namespace std; void handler(int signo) { 
    sleep(3); pid_t rid; while((rid = waitpid(-1, nullptr, WNOHANG)) > 0) { 
    cout << "I am process: " << getpid() << ", catch a signo: " << signo << "child process quit: " << rid << endl; } } int main() { 
    srand(time(nullptr)); signal(17, handler); for(int i = 0; i < 10; i++) { 
    pid_t id = fork(); if(id == 0) { 
    while(true) { 
    cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl; sleep(10); break; } cout << "child quit...!!!" << endl; exit(0); } sleep(rand() % 5 + 3); } //father while(true) { 
    cout << "I am father process: " << getpid() << endl; sleep(1); } return 0; } 

事实上,由于UNIX 的历史原因,要想不产生僵尸进程还有另外一种办法:父进程调 用sigaction将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不会产生僵尸进程,也不会通知父进程。系统默认的忽略动作和用户用sigaction函数自定义的忽略 通常是没有区别的,但这是一个特例。此方法对于Linux可用,但不保证在其它UNIX系统上都可 用。

#include <iostream> #include <unistd.h> #include <signal.h> #include <cstring> #include <time.h> #include <sys/wait.h> #include <sys/types.h> using namespace std; int main() { 
    signal(17, SIG_IGN); srand(time(nullptr)); for(int i = 0; i < 10; i++) { 
    pid_t id = fork(); if(id == 0) { 
    while(true) { 
    cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl; sleep(10); break; } cout << "child quit...!!!" << endl; exit(0); } sleep(rand() % 5 + 3); } //father while(true) { 
    cout << "I am father process: " << getpid() << endl; sleep(1); } return 0; } 

运行结果如下，可以看到是没有僵尸进程的

这里需要注意的是，默认是SIG_DFL，它的动作是忽略。和SIG_IGN是不一样的！！！