信号捕捉、可重入函数、volatile、SIGCHLD

news2024/12/21 4:36:30

个人主页：Lei宝啊

愿所有美好如期而遇

信号捕捉

signal

这个函数我们前面关于信号的文章多次提及，这里重点介绍sigaction。

sigaction

只需要看红色框住的属性即可，其余属性我们不使用，不用多管。第一个handler和signal的第二个参数意义是一样的，sa_mask是设置阻塞信号，sa_flags直接设为0即可。

在这里我们要提到的是：当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止，避免了嵌套式的信号处理。

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

using namespace std;

void Print()
{
    sigset_t pending;
    sigpending(&pending);

    for (int i = 31; i > 0; i--)
    {
        if (sigismember(&pending, i))
            cout << "1";
        else
            cout << "0";
    }
    cout << endl;
}

void handler(int signo)
{
    cout << "signo" << endl;

    int cnt = 10;
    while(cnt)
    {
        sleep(1);
        cnt--;
        Print();
    }

}

int main()
{

    struct sigaction sig;

    //这里其实不需要创建block，可以用sig系列函数直接操作sa_mask
    sigset_t block;
    sigemptyset(&block);

    sig.sa_flags = 0;
    sig.sa_mask = block;
    sig.sa_handler = handler;

    int val = sigaction(2, &sig, nullptr);
    if(val < 0) cout << "error" << endl;
    //signal(2, handler);

    while(true)
    {
        Print();
        sleep(1);
    }

    return 0;
}

我们也证明了这一点。

可重入函数

在我们执行insert函数时，进程时间片结束，检测到信号，并进行了捕捉，在捕捉函数中又调用了insert函数，最终导致未定义结果，像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入。

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

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

volatile

volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作。

下面我们写个代码举例：

#include <iostream>
#include <signal.h>

using namespace std;

int flag = 0;

void handler(int signo)
{
    flag = 1;
    cout << "flag = " << flag << endl;  
}

int main()
{

    signal(2, handler);
    while(!flag);

    cout << "process exit " << endl;
    return 0;
}

我们首先关闭优化进行编译运行：

接着我们打开优化：

这是因为编译器开启优化后，在主函数中没有检测到flag将会被做任何修改，于是将他放在了寄存器中，将来取flag值就去寄存器拿，而我们在内存中堆flag的修改不会对结果有任何影响了。

接下来我们给flag变量加上volatile修饰：

volatile int flag = 0;

SIGCHLD

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

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <wait.h>
using namespace std;

void handler(int signo)
{
    while(true)
    {
        //阻塞等待
        int val = waitpid(-1,nullptr,WNOHANG);
        if(val <= 0) break;
        else cout << "wait success" << endl;
    }
}

int main()
{

    signal(SIGCHLD, handler);

    for(int i=0; i<100; i++)
    {
        int id = fork();
        if(id == 0)
        {
            cout << "I am forked , pid: " << getpid() << endl;
            sleep(1);
            exit(0);
        }
    }

    while(1) sleep(1);

    return 0;
}

我们解释一下handler函数，首先，由于可能会有多个子进程结束，所以我们需要循环等待，再一个，因为可能不是所有子进程都释放了，所以我们选择非阻塞等待，将已经结束的子进程回收后跳出死循环，等待其他子进程结束发送信号调用自定义处理方法。

另一种处理方式：

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

int main()
{

    signal(SIGCHLD,SIG_IGN);

    for(int i=0; i<100; i++)
    {
        int id = fork();
        if(id == 0)
        {
            cout << "I am forked , pid: " << getpid() << endl;
            sleep(1);
            exit(0);
        }
    }

    while(1) sleep(1);

    return 0;
}