Linux

关注公众号 jb51net

关闭
首页 > 网站技巧 > 服务器 > Linux > Linux进程信号

Linux进程信号的使用解读

作者：有没有没有重复的名字

这篇文章主要介绍了Linux进程信号的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

什么是信号

信号是进程之间事件异步通知的一种方式，属于软中断。

前后台进程

Linux中，一次登录，一个终端一般会配上一个bash，每一次登录，只允许一个进程是前台进程，可以允许多个后台进程

本质区别（前台进程获取键盘输入）

前台进程

 ./运行后bash不再接受任何指令的进程（bash变为后台），可以用ctrl c二号信号杀掉

后台进程

./proc & 运行（ctrl c不能退出：键盘输入给bash，后台进程接受不到键盘输入），可以用ctrl /杀掉

键盘是如何输入给内核，ctral+c如何变成信号的

键盘也是文件 ，具有文件缓冲区，操作系统开机后加载到内存里，，即把键盘上数据拷贝到文件缓冲区，再通过接口将文件缓冲区内数据拷贝到用户缓冲区

但是如何知道键盘有数据呢？

键盘可以给CPU发送硬件中断（终端号），操作系统识别到中断号，以中断号为索引到中断表里找方法，再执行。然后将数据发送给CPU寄存器（高低电平）。

信号概念 

查看信号

 编号34以上的是实时信号

信号是数字，这里是宏定义

信号处理常见方式

可选的处理动作有以下三种:

signal函数

信号的产生

键盘组合键

kill命令

kill -9 pid即可

系统调用

kill

 mykill：
#include <iostream>
#include <string>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

using namespace std;

void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " signum pid\n\n";
}

int main(int argc, char *argv[])
{
    
     if(argc != 3)
     {
         Usage(argv[0]);
         exit(1);
     }
     int signum = stoi(argv[1]);
     pid_t pid = stoi(argv[2]);

     int n = kill(pid, signum);
     if(n == -1)
     {
         perror("kill");
         exit(2);
     }

    return 0;
}

./mykill 9 进程pid即可 

 raise

给调用者发送一个制定信号

#include <iostream>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

using namespace std;

void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " signum pid\n\n";
}

// mykill signum pid
int main(int argc, char *argv[])
{
    // signal(2, myhandler);
    int cnt = 0;
    while (true)
    {
        cout << "I am a process, pid: " << getpid() << endl;
        sleep(1);
        cnt++;
        if(cnt % 2 == 0) 
        {
            //kill(getpid(), 2);
            raise(2);      
        }
    }
    return 0；
}

abort

引起一个正常信号直接终止（发送6号信号）

#include <iostream>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

using namespace std;

void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " signum pid\n\n";
}

void myhandler(int signo)
{
    cout << "process get a signal: " << signo <<endl;
    // exit(1);
}

// mykill signum pid
int main(int argc, char *argv[])
{
    // signal(2, myhandler);
    
    signal(SIGABRT, myhandler);
    int cnt = 0;
    while (true)
    {
        cout << "I am a process, pid: " << getpid() << endl;
        sleep(1);
        cnt++;
        if(cnt % 2 == 0) 
        {
            //kill(getpid(), 2);
            //raise(2);   
            abort();   
        }
    }
    return 0；
}

此时发现即便把abort信号捕捉了仍然会abort退出

但是如果把abort注释，用在终端用kill -6 pid不会终止

总结 

无论哪种产生方式，最终一定是操作系统发送给操作系统的，因为操作系统是进程的管理者

异常 

硬件

除零错误
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

void handler(int signo)
{
    cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
}

int main()
{
    signal(SIG_FPE, handler);
    cout<<"div before"<<endl;
    sleep(1);
    int a = 10;
    int b = 0;

    a /= b;
    cout<<"div after"<<endl;
    sleep(1);
    return 0;

}
野指针问题
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

void handler(int signo)
{
    cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
}

int main()
{
    signal(SIGSEGV, handler);
    cout<<"point error before"<<endl;
    sleep(1);
    int *p = nullptr;
    *p = 100;

    cout<<"point error after"<<endl;
    sleep(1);
    return 0;

}

操作系统如何知道错误了呢？

除零错误时：CPU内状态寄存器的溢出标志位被置为1，操作系统会知道（OS是硬件的管理者），向进程发送信号，杀死进程。

任何异常只会影响对应进程，不会波及到操作系统

进程出异常与进程是否切换无关，当进程被调度时要把自己进程上下文带走，把别人上下文拿回来（而CPU中状态寄存器输入上下文）

野指针错误时：页表的查询由MMU（硬件内存管理单元）完成，出现异常访问时，页表转换时因权限问题或映射问题转换失败

虚拟到物理地址转换失败，MMU硬件单元报错，将转换失败的虚拟地址放到CPU一个寄存器里

出现异常不崩溃会一直被调度，捕捉信号不是为了解决异常，而是让用户清除为什么挂掉

捕捉信号不是为了解决异常而是让用户清楚为什么进程会挂掉 

core dump

当⼀个进程要异常终⽌时,可以选择把进程的⽤户空间内存数据全部保存到磁盘上,⽂件名通常是core,这叫做Core Dump。

云服务器core默认为0，需要自己修改

示例代码： 

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // signal(2, SIG_IGN);
    signal(2, SIG_DFL);



    pid_t id = fork();
    if(id == 0)
    {
        //child
        int cnt = 500;
        while(cnt)
        {
            cout << "i am a child process, pid: " << getpid() << "cnt: " << cnt << endl;
            sleep(1);
            cnt--;
        }

        exit(0);
    }

    // father
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid == id)
    {
        cout << "child quit info, rid: " << rid << " exit code: " << 
            ((status>>8)&0xFF) << " exit signal: " << (status&0x7F) <<
                " core dump: " << ((status>>7)&1) << endl; // ? & (0000 0000 ... 0001)
    }
    return 0;
}

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // signal(2, SIG_IGN);
    signal(2, SIG_DFL);

    while (1)
    {
        cout << "hello signal" << endl;
        sleep(1);
    }

    int a = 10;
    int b = 0;

    a /= b;

    cout << " a = " << a << endl;
    return 0;
}

core dump复现问题错误后直接定位到出错行 ，方便事后调试。

软件

例如：管道如果只有读没有写就会触发异常

闹钟的返回值是闹钟响之后的剩余时间，如果有多个闹钟就返回上个脑中的剩余时间 

闹钟响过后默认调用17号信号，但闹钟不是异常，如果进行信号捕捉，里边没有写退出的话，响过后不会终止程序 

如果想每隔n秒响一次，就在捕捉后再次设置闹钟即可

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

using namespace std;
void work()
{
    cout << "print log..." << endl;
}

// 信号为什么会一直被触发？？
void handler(int signo)
{
    // work();
    cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
    // exit(1);
    int n = alarm(5);
    cout << "剩余时间：" << n << endl;
}

int main()
{
    signal(SIGALRM, handler);
    int n = alarm(50);

    while(1)
    {
        cout << "proc is running..., pid: " << getpid() << endl;
        sleep(1);
    }

    sleep(1);

    return 0;
}

信号的保存

信号的发送是给进程的pcb发

task_struct结构体里有int single对象，int32位比特位（普通信号，位图管理信号）

比特位的内容是1还是0表明是否收到

比特位的位置（第几个）表示信号的编号

所谓的发信号，本质就是OS去修改task_struct中的信号位图对应的比特位（实质是写信号）

发信号的一定是操作系统，操作系统是进程的管理者，只有OS才能修改task_struct内部的属性

信号其他相关常见概念

实际执行信号的处理动作称为信号递达

信号从产生到递达之间的状态,称为信号未决。 进程可以选择阻塞某个信号。

被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.

注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。

 在内核中的表示

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

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

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

handler表：

pending表：

block表：

阻塞（屏蔽）和忽略

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // signal(2, SIG_IGN);
    signal(2, SIG_DFL);

    while(1)
    {
        cout << "hello signal" << endl;
        sleep(1);
    }
    return 0;
}

sigset_t（数据类型）

从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。 因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储

sigset_t称为信号集,这个类型可以表示每个信号 的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有 效”和“无效”的含义是该信号是否处于未决状态。阻塞信号集也叫做当前进程的信号屏蔽字

这里的“屏蔽”应该理解为阻塞而不是忽略。  

信号集操作函数

信号集是系统提供的一种数据类型，方便我们未来对pending表和block表做操作

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);

1.函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号。

2.函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系 统支持的所有信号。

3.注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

4.这四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含 某种 信号,若包含则返回1,不包含则返回0,出错返回-1。

 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参数的可选值。

sigset_t *oset：输出型参数，将上一个block表进行保存（为了未来恢复）

sigpending

读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。 

set输出型参数：把pending表以位图形式带出来

示例代码：

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

using namespace std;

void PrintPending(sigset_t &pending)
{
    for (int signo = 31; signo >= 1; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << "\n\n";
}

void handler(int signo)
{
    cout << "catch a signo: " << signo << endl;
}

int main()
{
    // 0. 对2号信号进行自定义捕捉
    signal(2, handler);

    // 1. 先对2号信号进行屏蔽 --- 数据预备
    sigset_t bset, oset; // 在哪里开辟的空间？？？用户栈上的，属于用户区
    sigemptyset(&bset);
    sigemptyset(&oset);
    sigaddset(&bset, 2); // 我们已经把2好信号屏蔽了吗？并没有设置进入到你的进程的task_struct
    // 1.2 调用系统调用，将数据设置进内核
    sigprocmask(SIG_SETMASK, &bset, &oset); // 我们已经把2好信号屏蔽了吗？ok

    // 2. 重复打印当前进程的pending 0000000000000000000000000
    sigset_t pending;
    int cnt = 0;
    while (true)
    {
        // 2.1 获取
        int n = sigpending(&pending);
        if (n < 0)
            continue;
        // 2.2 打印
        PrintPending(pending);

        sleep(1);
        cnt++;
        // 2.3 解除阻塞
        if(cnt == 20)
        {
            cout << "unblock 2 signo" << endl;
            sigprocmask(SIG_SETMASK, &oset, nullptr); // 我们已经把2好信号屏蔽了吗？ok
        }
    }
    // 3 发送2号 0000000000000000000000010

    return 0;
}

9号和19号新号不可以被捕捉和屏蔽（演示代码）

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

using namespace std;

void PrintPending(sigset_t &pending)
{
    for (int signo = 31; signo >= 1; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << "\n\n";
}

void handler(int signo)
{
    cout << "catch a signo: " << signo << endl;
}

int main()
{
    // 4. 我可以将所有的信号都进行屏蔽，信号不就不会被处理了吗？ 肯定的！9
    sigset_t bset, oset;
    sigemptyset(&bset);
    sigemptyset(&oset);
    for (int i = 1; i <= 31; i++)
    {
        sigaddset(&bset, i); // 屏蔽了所有信号吗？？？
    }
    sigprocmask(SIG_SETMASK, &bset, &oset);

    sigset_t pending;
    while (true)
    {
        // 2.1 获取
        int n = sigpending(&pending);
        if (n < 0)
            continue;
        // 2.2 打印
        PrintPending(pending);
        sleep(1);
    }
    return 0;
}

信号处理

信号是什么时候被处理的

刚开机操作系统就加载了，所以在物理内存较靠下的位置 ，进程pcb的3——4G空间是内核空间，由内核级页表映射到物理内存，内核级页表只有一个（所有进程都可以看到），用户级页表好几个（进程具有独立性）。

进程视角：调用系统中的方法时，就是在自己的地址空间中进行的（类似于共享区与代码段之间的跳转）。

操作系统视角：任何一个时刻，都是有进程执行的，我们想执行操作系统的代码就可以执行。

操作系统的本质是一个死循环。

操作系统的运行是被动的，由时钟来推动进行，当时钟信号来时，停止运行当前进程代码，去查看进程的调度，只要进程在跑，cpu就会调度进程，只要调度，时间片就会被消耗完毕，消耗完后把进程从CPU上剥离下来。（下次调度将pcb等汇总到CPU上（内核态））

操作系统不相信用户还体现在不会执行用户的代码（要执行代码必须从内核态跳转到用户态）

没用调用系统调用的代码也会有内核态和用户态的切换（二次调用时）上边红字

信号捕捉

内核如何实现信号的捕捉

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码 是在用户空间的,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数sighandler。 当前正在执行 main函数,这时发生中断或异常切换到内核态。

在中断处理完毕后要返回用户态的main函数之前检查到有信号 SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函 数,sighandler 和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是 两个独立的控制流程。

sighandler函数返 回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复 main函数的上下文继续执行了。  

实现信号捕捉代码

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

using namespace std;

void handler(int signo)
{
    cout<< "catch a signal, signal number : " << signo << endl;
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    act.sa_handler = handler;

    sigaction(2,&act,&oact);

    while (true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

pending位图，什么时候从1->0

当进行信号处理时，倘若已经进入到了信号的捕捉代码里，先把信号位图由1清零，才调用handler方法

执行信号捕捉方法之前，先清0，在调用

演示代码

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

using namespace std;

void PrintPending()
{
    sigset_t set;
    sigpending(&set);

    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&set, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    PrintPending();
    sleep(1);
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    act.sa_handler = handler;

    sigaction(2,&act,&oact);

    while (true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

当某个信号的处理函数被调用时

内核自动将当前信号加入进程的信号屏蔽字

信号被处理的时候，对应的信号也会被添加到block表中，防止信号捕捉被嵌套调用

操作系统不允许对同一种信号进行嵌套式的捕捉（如果没有屏蔽会导致在处理时调用handler函数）

当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。 

演示代码

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

using namespace std;

void PrintPending()
{
    sigset_t set;
    sigpending(&set);

    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&set, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    cout << "catch a signal, signal number : " << signo << endl;
    while (true)
    {
        PrintPending();
        sleep(1);
    }
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    act.__sigaction_handler = handler;

    sigaction(2,&act,&oact);

    while (true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

如果在调用信号处理函数时

除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号

示例代码 

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

using namespace std;

void PrintPending()
{
    sigset_t set;
    sigpending(&set);

    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&set, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    cout << "catch a signal, signal number : " << signo << endl;
    while (true)
    {
        PrintPending();
        sleep(1);
    }
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 1);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);

    act.__sigaction_handler = handler;

    sigaction(2, &act, &oact);

    while (true)
    {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

可重入函数

会导致节点丢失，内存泄漏问题

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

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

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

调用了malloc或free,因为malloc也是用全局链表来管理堆的。

调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

volatile

makefile

mysignal:mysignal.cc
	g++ -o $@ $^ -O3 -g -std=c++11
.PHONY:clean
clean:
	rm -f mysignal
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

volatile int flag = 0;

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

int main()
{
    signal(2, handler);
    // 在优化条件下， flag变量可能被直接优化到CPU内的寄存器中
    while(!flag); // flag 0, !falg 真

    cout << "process quit normal" << endl;
    return 0;
}

SIGCHLD信号

子进程退出时主动向父进程发送SIGCHLD（17）信号

#include <iostream>
#include <cstdlib>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
 
void handler(int signo)
{
     void handler(int signo)
 {
     sleep(5);
     pid_t rid;
     while ((rid = waitpid(-1, nullptr, WNOHANG)) > 0)
     {
         cout << "I am proccess: " << getpid() << " catch a signo: " << signo << "child             
          process quit: " << rid << endl;
     }
 }
}
 
// 验证子进程退出，给父进程发送SIGCHLD
int main()
{
    signal(SIGCHLD, handler);
    // 问题1: 1个子进程，10个呢？
    // 问题2: 10个子进程，6个退出了！
    for (int i = 0; i < 10; i++)
    {
        if (fork() == 0)
        {
            sleep(5);
            std::cout << "子进程退出" << std::endl;
            // 子进程
            exit(0);
        }
    }
 
    while (true)
    {
        sleep(1);
    }
    return 0;
}

如果不用知道子进程退出结构直接这样即可。

int main()
{
    signal(SIGCHLD, handler);
    // 问题1: 1个子进程，10个呢？
    // 问题2: 10个子进程，6个退出了！
    for (int i = 0; i < 10; i++)
    {
        if (fork() == 0)
        {
            sleep(5);
            std::cout << "子进程退出" << std::endl;
            // 子进程
            exit(0);
        }
    }
 
    while (true)
    {
        sleep(1);
    }
    return 0;
}

17号信号默认SIG_DFL他的默认行为是IGN，所以仍旧会有僵尸进程

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文