当前位置： 首页 > article >正文

【Linux系统】SIGCHLD 信号（选学了解）

article 2025/2/5 17:06:35




在这里插入图片描述




SIGCHLD 信号


使用wait和waitpid函数可以有效地清理僵尸进程。父进程可以选择阻塞等待，直到子进程结束；或者采用非阻塞的方式，通过轮询检查是否有子进程需要被回收。

然而，无论是选择阻塞等待还是非阻塞的轮询方式，父进程与子进程之间都无法实现真正的异步执行，因为父进程仍需“分心”来管理子进程的状态。

当子进程终止时，会向父进程发送一个SIGCHLD信号，这个信号的默认行为是被忽略。不过，父进程可以通过设置自定义的SIGCHLD信号处理函数来改变这一行为。这样，父进程就可以专注于自己的任务，无需直接管理子进程的状态。一旦子进程终止，它会通知父进程，父进程只需要在其信号处理函数中调用wait或waitpid来清理子进程即可。

因此，我们能够通过自定义处理子进程发出的SIGCHLD信号，在接收到该信号时利用waitpid回收子进程资源。这种方法避免了主动等待子进程的结束，使得父子进程之间能够更加高效地异步执行。



演示代码如下：因为需要在函数 handler 中使用子进程 id，因此定义了一个全局变量 id

其实还有一种方法不用传id也不用定义全局变量：waitpid(-1, nullptr, 0);

-1 表示回收该父进程下的任意一个子进程

当 pid 参数为 -1 时，waitpid 函数会等待任何一个子进程的状态变化。这意味着它会捕获任何已经终止的子进程，并回收其资源。这对于处理多个子进程的情况非常有用，因为父进程不需要知道具体是哪个子进程终止了。

#include<iostream>  // 引入输入输出流库
#include<signal.h> // 引入信号处理库
#include<sys/wait.h> // 引入等待子进程状态改变的函数库
#include<sys/types.h> // 引入系统类型定义
#include<unistd.h> // 引入Unix标准函数库


pid_t id; // 定义全局变量id，用于存储子进程ID

// 定义信号处理函数
void handler(int signum)
{
    waitpid(id, nullptr, 0); // 等待子进程结束，回收子进程资源

    std::cout << "子进程退出, 我也退出了" << '\n'; // 输出子进程已退出的信息
    // 当接收到信号时，调用raise给自己发送9号信号（SIGKILL），强制终止进程
    raise(9);
}

int main()
{
    id = fork(); // 创建子进程
    if(id < 0)
    {
        perror("fork"); // 如果fork失败，输出错误信息
        return 1; // 返回错误码1
    }

    // 子进程逻辑
    if(id == 0)
    {
        std::cout << "I am 子 process" << '\n'; // 子进程输出标识信息
        sleep(2); // 子进程暂停2秒
        exit(0); // 子进程正常退出
    }
    // 父进程逻辑
    else if (id > 0)
    {
        std::cout << "I am 父 process" << '\n'; // 父进程输出标识信息
        signal(SIGCHLD, handler); // 设置SIGCHLD信号的处理函数为handler
        int cnt = 0; // 初始化计数器
        while(1)
        {   
            sleep(1); // 每秒暂停1秒
            std::cout << "cnt = " << cnt++ << '\n'; // 输出当前计数值
        }
    }   

    return 0; // 程序正常结束
}


运行结果如下：

在这里插入图片描述



问题一：如果同时多个子进程退出，是否会全部回收


但是这样通过信号回收子进程是有一定风险的！

因为信号是通过 pending 位图保存的，当一个父进程同时有多个子进程同时退出，同时发送 SIGCHLD 信号，则位图不能记录信号接收数量，就大概率会遗漏处理某些子进程，导致多个子进程僵尸的情况

验证如下：

#include <iostream>      // 引入输入输出流库
#include <signal.h>      // 引入信号处理库
#include <sys/wait.h>    // 引入等待子进程状态改变的函数库
#include <sys/types.h>   // 引入系统类型定义
#include <unistd.h>      // 引入Unix标准函数库

// 定义信号处理函数
void handler(int signum)
{
    pid_t id = waitpid(-1, nullptr, 0); // 等待任意一个子进程结束，回收其资源
    std::cout << "回收子进程 id : " << id << '\n'; // 输出回收的子进程ID
}

int main()
{
    pid_t id; // 定义变量id，用于存储子进程ID

    // 循环创建15个子进程
    for (int i = 1; i <= 15; ++i)
    {
        id = fork(); // 创建子进程
        if (id < 0)
        {
            perror("fork"); // 如果fork失败，输出错误信息
            return 1; // 返回错误码1
        }
        // 子进程逻辑
        if (id == 0)
        {
            std::cout << "I am 子 process" << '\n'; // 子进程输出标识信息
            sleep(2); // 子进程暂停2秒
            exit(0); // 子进程正常退出
        }
    }

    // 父进程逻辑
    if (id > 0)
    {
        std::cout << "I am 父 process" << '\n'; // 父进程输出标识信息
        signal(SIGCHLD, handler); // 设置SIGCHLD信号的处理函数为handler，当子进程结束时会触发此函数

        int cnt = 0; // 初始化计数器
        while (1)
        {
            sleep(1); // 每秒暂停1秒
            std::cout << "cnt = " << cnt++ << '\n'; // 输出当前计数值
        }
    }

    return 0; // 程序正常结束
}


运行结果如下：不少子进程没有被回收，而是变成了僵尸进程

在这里插入图片描述



解决办法：循环等待回收子进程，否则退出


演示代码如下：

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

void handler(int signum)
{
    while (true)
    {
        pid_t id = waitpid(-1, nullptr, 0);
        if(id > 0)
        {
            std::cout << "回收子进程 id : " << id << '\n';
        }
        else if(id < 0)
        {
            std::cout << "回收完毕, 暂时结束回收\n";
            break;
        }
    }
}

int main()
{
    pid_t id;
    for (int i = 1; i <= 15; ++i)
    {
        id = fork();
        if (id < 0)
        {
            perror("fork");
            return 1;
        }
        // 子进程
        if (id == 0)
        {
            std::cout << "I am 子 process" << '\n';
            sleep(2);
            exit(0);
        }
    }

    // 父进程
    if (id > 0)
    {
        std::cout << "I am 父 process" << '\n';
        signal(SIGCHLD, handler);
        int cnt = 0;
        while (1)
        {
            sleep(1);
            std::cout << "cnt = " << cnt++ << '\n';
        }
    }

    return 0;
}


运行结果如下：自己可以去查询，可以确定当前没有僵尸子进程

在这里插入图片描述



问题二：如果有子进程不退出，问题一中的循环wait，是否会退出循环


演示代码：

// 创建一个不退出的子进程
id = fork();
if (id == 0)
{
    std::cout << "I am 不退出的子进程" << '\n';
   	sleep(6);
}

结果就是 循环没退出，因为 waitpid 是阻塞式等待，会等待子进程退出，因为该子进程不退出则循环不退出一直阻塞等待


因此需要换成非阻塞式等待，同时当 waitpid 的返回值为 0，说明当前没有退出的子进程，则此时可以主动退出循环

pid_t id = waitpid(-1, nullptr, WNOHANG);


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

void handler(int signum)
{
    while (true)
    {
        pid_t id = waitpid(-1, nullptr, WNOHANG);
        if (id > 0)
        {
            std::cout << "回收子进程 id : " << id << '\n';
        }
        else if(id == 0) // 表示没有子进程退出了(注意是没有退出的子进程了, 不是没有子进程)
        {
            std::cout << "暂时没有子进程退出\n";
            break;
        }
        else if (id < 0) // 表示没有子进程了
        {
            std::cout << "waitpid error\n";
            break;
        }
    }
}

int main()
{
    pid_t id;
    for (int i = 1; i <= 15; ++i)
    {
        id = fork();
        if (id < 0)
        {
            perror("fork");
            return 1;
        }
        // 子进程
        if (id == 0)
        {
            std::cout << "I am 子 process" << '\n';
            sleep(2);
            exit(0);
        }
    }

    // 创建一个不退出的子进程
    id = fork();
    if (id == 0)
    {
        std::cout << "I am 不退出的子进程" << '\n';
        sleep(6); // 时间长点, 模拟短时间内不退出
    }

    // 父进程
    if (id > 0)
    {
        std::cout << "I am 父 process" << '\n';
        signal(SIGCHLD, handler);
        int cnt = 0;
        while (1)
        {
            sleep(1);
            std::cout << "cnt = " << cnt++ << '\n';
        }
    }

    return 0;
}


运行结果如下

在这里插入图片描述


waitpid 系统调用的工作原理如下：

  • 阻塞等待：当 waitpid 被调用时，如果当前没有符合条件的已退出子进程，内核会让父进程进入阻塞状态。这意味着父进程会被挂起，不再占用CPU时间，直到有子进程的状态发生变化（通常是退出）。
  • 非阻塞等待：如果 waitpid 调用时传递了 WNOHANG 选项，内核会立即返回，即使没有子进程退出。在这种情况下，waitpid 不会阻塞父进程。
  • 状态变化通知：当一个子进程退出时，内核会检查该子进程的父进程是否正在等待子进程的状态变化。如果是，内核会唤醒父进程，使其从 waitpid 调用中返回，并传递子进程的退出状态。
  • 资源回收：父进程通过 waitpid 获得子进程的退出状态后，内核会释放子进程占用的资源，防止子进程变成僵尸进程。

意思是：父进程使用waitpid 系统调用时，若为阻塞等待，则OS将该父进程挂起（即阻塞），当目标子进程退出时，若该父进程正处于等待子进程退出的状态，则OS会传递子进程退出状态信息并使父进程退出阻塞状态（即使其从 waitpid 调用中返回）



子进程退出，OS是如何知道的，是因为OS需要轮询子进程的状态吗

当然不是OS轮询，前面讲解过 OS 就是一个躺在中断向量表上的一个代码块，OS的运行基本靠中断，因此进程退出也是通过中断通知OS，使其执行相应的后续”善后“工作


意思是子进程退出时，会向OS发送软件中断，此时进入内核态，执行该中断对应的中断处理例程：即更新子进程的 PCB，将子进程的状态标记为“已退出”（Zombie 状态），生成一个 SIGCHLD 信号并发送给父进程


子进程退出的详细过程

  1. 子进程调用 exit 或 exit_group 系统调用：
    • 子进程在调用 exit 或 exit_group 系统调用时，会进入内核态。
      • 不是子进程退出子进程发送的软件中断，而是子进程在调用 exit 或 exit_group 系统调用触发的软件中断
  2. 进入内核态：
    • 当子进程调用 exit 或 exit_group 时，控制权转移到内核，进入内核态。
    • 内核会执行相应的中断处理例程（中断服务程序）。
  3. 中断处理例程：
    • 内核的中断处理例程会执行以下操作：
      • 更新子进程的 PCB：内核会更新子进程的进程控制块（PCB），将子进程的状态标记为“已退出”（Zombie 状态）。
      • 生成 SIGCHLD 信号：内核会生成一个 SIGCHLD 信号并发送给父进程。
  4. 父进程接收 SIGCHLD 信号：
    • 父进程接收到 SIGCHLD 信号后，会调用预先注册的信号处理函数（如 handler）默认为忽略


主动忽略子进程的 SIGCHLD

Linux下，将SIGCHLD的处理动作置为SIG IGN,这样fork出来的子进程在终止时会自动清理掉

由于UNIX 的历史原因,要想不产⽣僵⼫进程还有另外⼀种办法:⽗进程调 ⽤sigaction将
SIGCHLD的处理动作置为SIG_IGN,这样fork出来的⼦进程在终⽌时会⾃动清理掉,不 会产⽣僵⼫进程,

也不会通知⽗进程。系统默认的忽略动作和⽤⼾⽤sigaction函数⾃定义的忽略 通常是没有区别的,但这
是⼀个特例。此⽅法对于Linux可⽤,但不保证在其它UNIX系统上都可 ⽤。

signal(SIGCHLD, SIG_IGN);


底层原理：

父进程未调用 waitpid 的情况

  1. 子进程退出：
    • 子进程调用 exit 或 exit_group 系统调用，进入内核态。
    • 内核更新子进程的 PCB，将其状态标记为“已退出”（Zombie 状态）。
    • 内核生成 SIGCHLD 信号并发送给父进程。
  2. 父进程处理 SIGCHLD 信号：
    • 如果父进程注册了 SIGCHLD 信号处理函数（如 handler），内核会调用该处理函数。
    • 在信号处理函数中，父进程可以调用 waitpid 来获取子进程的退出状态并释放资源。
  3. 父进程忽略 SIGCHLD 信号：
    • 如果父进程将 SIGCHLD 信号的处理动作设置为 SIG_IGN，内核会自动回收子进程的资源，子进程不会变成僵尸进程。
    • 这意味着父进程不需要显式调用 wait 或 waitpid 来回收子进程的资源。


问题：父进程忽略了该信号，内核如何知道父进程忽略了，然后进行的自动回收子进程的资源

  1. 内核记录信号处理动作：

    • 内核会记录每个进程的信号处理动作。当父进程调用 signal 或 sigaction 设置 SIGCHLD 信号的处理动作时，内核会更新父进程的信号处理表。

    • 内核会记录 SIGCHLD 信号的处理动作为 SIG_IGN。

子进程调用退出

  1. 内核生成 SIGCHLD 信号：
    • 内核生成 SIGCHLD 信号并准备发送给父进程。
    • 内核会检查父进程的信号处理表，查看 SIGCHLD 信号的处理动作。
  2. 检查信号处理动作：
    • 如果父进程的信号处理动作是 SIG_IGN，内核会知道父进程忽略了 SIGCHLD 信号。
    • 内核会自动回收子进程的资源，子进程不会变成僵尸进程。


问题：系统对该信号的默认处理不就是忽略吗，为什么我们还要自己主动忽略

系统默认的忽略动作和⽤⼾⽤sigaction函数⾃定义的忽略 通常是没有区别的,但这
是⼀个特例。此⽅法对于Linux可⽤,但不保证在其它UNIX系统上都可 ⽤。

其实，因为位图本身一次只能记录一个进程退出信号，因此即使循环等待等操作，还是会有极小概率处理不了某些退出子进程


http://www.kler.cn/a/532683.html

相关文章：

  • Maven（Ⅱ）：依赖范围，依赖传递，依赖阻断，可选依赖
  • 25.02.04 《CLR via C#》 笔记14
  • CSS Display属性完全指南
  • 【Linux系统】信号：再谈OS与内核区、信号捕捉、重入函数与 volatile
  • HTMLCSS ：下雪了
  • Spring Boot框架下的单元测试
  • 基于微信小程序的私家车位共享系统设计与实现（LW+源码+讲解）
  • linux内核源代码中__init的作用？
  • 【仿12306项目】基于SpringCloud，使用Sentinal对抢票业务进行限流
  • Linux01——初识Linux
  • 【Python】NumPy（一）：数据类型、创建数组及基本操作
  • Docker使用指南（二）——容器相关操作详解（实战案例教学，创建/使用/停止/删除）
  • 开发指南094-in语句的处理
  • Maven（Ⅱ）：依赖范围，依赖传递，依赖阻断，可选依赖
  • 10分钟本地部署Deepseek-R1
  • Laravel Validation validated() 的实现
  • Selenium记录RPA初阶 - 基本输入元件
  • js --- 获取随机数
  • 预防和应对DDoS的方法
  • 【力扣】283.移动零
  • springboot后台系统开发（三）- 日志
  • 【OS】AUTOSAR架构下的Interrupt详解（上篇）
  • 某某音乐歌单下载（电脑）
  • 物联网领域的MQTT协议，优势和应用场景
  • spark君第一篇图文讲解Delta源码和实践的文章
  • C基础寒假练习(8)