Linux应用：进程的回收

进程的诞生和消亡

程的诞生通常是通过系统调用（如fork、exec等）来创建新进程。当一个进程完成其任务或者出现错误时，它会进入消亡阶段。进程可以通过exit函数主动结束自身，也可能由于操作系统的调度策略（如资源耗尽、进程异常终止等）而被强制终止。进程结束后，操作系统会回收其占用的资源，如内存、文件描述符等。

进程的诞生

进程0

在操作系统启动过程中，进程 0 是最早被创建的进程，它是整个进程体系的始祖。进程 0 通常由操作系统内核直接初始化，承担着至关重要的任务，例如初始化系统关键数据结构、创建进程 1 等后续进程的基础环境搭建。它运行在内核态，拥有最高的权限，可以直接访问系统硬件资源，对系统的稳定运行起着决定性作用。在类 Unix 系统中，进程 0 也被称为 "swapper" 进程，其主要职责之一是负责进程调度的初始化，为后续进程能够在合适的时机获得 CPU 资源执行奠定基础。

进程1

进程 1 是进程 0 创建的第一个用户态进程，也被称作 "init" 进程。它是所有用户进程的祖先，在系统启动流程中，当内核完成自身初始化以及进程 0 的相关设置后，就会通过特定机制创建进程 1。进程 1 会读取系统配置文件，启动各种系统服务，比如网络服务、文件系统服务等。它负责管理系统中所有用户进程的生命周期，当某个用户进程异常终止时，进程 1 会回收其资源，避免资源泄漏。并且，进程 1 始终存在于系统中，直到系统关闭，是维持系统正常运行的核心进程之一。

fork

fork是 Unix 和类 Unix 系统中用于创建新进程的系统调用。当一个进程调用fork时，内核会为新进程分配独立的进程控制块（PCB），并复制调用进程（父进程）的大部分资源，包括内存空间（数据段、代码段、堆栈段等）、打开的文件描述符、信号处理函数等。新创建的进程（子进程）几乎与父进程一模一样，fork调用会在父进程和子进程中分别返回，在父进程中返回子进程的进程 ID（PID），而在子进程中返回 0。通过这种返回值的差异，程序可以区分当前是在父进程还是子进程中执行不同的逻辑。例如，父进程可能继续执行一些管理任务，而子进程可以执行特定的计算任务或启动新的程序。不过，由于资源复制操作，fork在创建进程时开销相对较大。

父进程可以有多个子进程。在操作系统中，父进程可以通过多次调用 fork 函数来创建多个子进程。每个子进程都是父进程的一个副本，它们可以独立执行不同的任务，并且父进程可以通过各种方式管理和与这些子进程进行交互。

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t pid1, pid2;

    // 创建第一个子进程
    pid1 = fork();
    if (pid1 < 0) {
        // 处理fork失败的情况
        perror("fork1");
        return 1;
    } else if (pid1 == 0) {
        // 第一个子进程的代码
        printf("我是第一个子进程，我的PID是 %d，父进程的PID是 %d\n", getpid(), getppid());
        // 子进程执行一些任务，这里简单地休眠2秒
        sleep(2);
        // 子进程退出
        exit(0);
    } else {
        // 父进程继续执行，创建第二个子进程
        pid2 = fork();
        if (pid2 < 0) {
            // 处理fork失败的情况
            perror("fork2");
            return 1;
        } else if (pid2 == 0) {
            // 第二个子进程的代码
            printf("我是第二个子进程，我的PID是 %d，父进程的PID是 %d\n", getpid(), getppid());
            // 子进程执行一些任务，这里简单地休眠3秒
            sleep(3);
            // 子进程退出
            exit(0);
        } else {
            // 父进程的代码
            printf("我是父进程，我的PID是 %d\n", getpid());
            // 父进程可以等待子进程结束，或者执行其他任务
            // 这里简单地等待一段时间
            sleep(5);
            printf("两个子进程都已结束，父进程继续执行其他任务...\n");
        }
    }

    return 0;
}

vfork

vfork也是用于创建新进程的系统调用，与fork有相似之处，但也存在显著差异。vfork创建子进程时，子进程与父进程共享内存空间，而不是像fork那样复制内存。这使得vfork创建进程的速度更快，开销更小。在vfork调用后，子进程会先运行，父进程会被阻塞，直到子进程调用exec系列函数（用于执行新的程序）或者exit退出。这种机制确保了子进程在使用共享内存时不会与父进程产生冲突。通常在需要快速创建进程并立即执行新程序的场景中，vfork会比fork更合适。例如，当一个进程需要频繁启动其他程序时，使用vfork可以减少资源开销，提高系统效率。

cpp 复制代码

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

int main() {
    pid_t pid;

    // 使用 vfork() 创建新进程
    pid = vfork();

    if (pid < 0) {
        // vfork() 失败
        std::cerr << "vfork() failed!" << std::endl;
        return 1;
    } else if (pid == 0) {
        // 子进程
        std::cout << "This is the child process. PID: " << getpid() << std::endl;
        // 子进程可以执行一些操作，这里简单地调用 exit()
        exit(0);
    } else {
        // 父进程
        int status;
        // 等待子进程结束
        waitpid(pid, &status, 0);
        std::cout << "This is the parent process. PID: " << getpid() << std::endl;
        std::cout << "Child process exited with status: " << WEXITSTATUS(status) << std::endl;
    }

    return 0;
}

包含必要的头文件：

：用于输入输出操作。

<unistd.h>：包含 vfork()、getpid() 等系统调用。

<sys/types.h>：包含一些基本的系统数据类型。

<sys/wait.h>：包含 waitpid() 函数。

：包含 exit() 函数。

使用 vfork() 创建新进程：

pid = vfork();：调用 vfork() 函数创建新进程。如果成功，父进程会返回子进程的 PID（大于 0），子进程会返回 0；如果失败，返回 -1。

错误处理：

if (pid < 0)：如果 vfork() 失败，输出错误信息并返回 1。

子进程处理：

else if (pid == 0)：子进程执行的代码。输出子进程的 PID，然后调用 exit(0) 结束子进程。

父进程处理：

else：父进程执行的代码。使用 waitpid() 等待子进程结束，并获取子进程的退出状态。输出父进程的 PID 和子进程的退出状态。

僵尸进程

当子进程先于父进程结束，且父进程没有及时调用wait系列函数来获取子进程的退出状态时，子进程就会成为僵尸进程。僵尸进程虽然已经结束运行，但它在系统中仍然占据一定的资源（如进程表项），直到父进程调用wait函数回收其资源。过多的僵尸进程可能会导致系统资源浪费，影响系统性能。

SIGCHILD 信号讲解

信号概述
在 Unix 或类 Unix 系统中，信号是一种软件中断机制，用于通知进程发生了某个特定事件。SIGCHILD 信号就是其中之一，它是由内核在以下几种情况下发送给父进程的：
子进程终止（正常退出或被信号终止）。
子进程停止（例如通过 SIGSTOP 信号）。
停止的子进程恢复执行（例如通过 SIGCONT 信号）。
信号处理的意义
父进程接收到 SIGCHILD 信号后，通常需要对其进行处理，以避免产生僵尸进程。僵尸进程是指子进程已经终止，但父进程尚未回收其资源（主要是进程表项）的进程。通过处理 SIGCHILD 信号，父进程可以及时回收子进程的资源，释放系统资源。
信号处理方式
父进程可以通过以下几种方式处理 SIGCHILD 信号：
忽略信号：将信号处理函数设置为 SIG_IGN，这样内核会自动回收子进程的资源，避免产生僵尸进程。但这种方式在某些情况下可能会导致一些问题，例如在多线程程序中。
自定义信号处理函数：父进程可以定义自己的信号处理函数，在函数中调用 wait 或 waitpid 函数来回收子进程的资源。

cpp 复制代码

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

int main() {
    // 忽略 SIGCHILD 信号
    signal(SIGCHLD, SIG_IGN);

    pid_t pid = fork();

    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("子进程开始执行，PID: %d\n", getpid());
        sleep(2);
        printf("子进程结束\n");
        exit(0);
    } else {
        // 父进程
        printf("父进程继续执行，子进程 PID: %d\n", pid);
        sleep(5);
        printf("父进程结束\n");
    }

    return 0;
}

signal(SIGCHLD, SIG_IGN);：将 SIGCHILD 信号的处理方式设置为忽略。这样，当子进程终止时，内核会自动回收其资源，不会产生僵尸进程。

子进程打印信息，睡眠 2 秒后退出。

父进程打印信息，睡眠 5 秒后结束。

cpp 复制代码

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

// 自定义信号处理函数
void sigchld_handler(int signo) {
    pid_t pid;
    int status;

    // 使用 waitpid 以非阻塞模式回收所有终止的子进程
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        if (WIFEXITED(status)) {
            printf("子进程 %d 正常结束，退出状态码: %d\n", pid, WEXITSTATUS(status));
        } else if (WIFSIGNALED(status)) {
            printf("子进程 %d 被信号 %d 终止\n", pid, WTERMSIG(status));
        }
    }
}

int main() {
    // 注册信号处理函数
    signal(SIGCHLD, sigchld_handler);

    pid_t pid = fork();

    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("子进程开始执行，PID: %d\n", getpid());
        sleep(2);
        printf("子进程结束\n");
        exit(10);
    } else {
        // 父进程
        printf("父进程继续执行，子进程 PID: %d\n", pid);
        sleep(5);
        printf("父进程结束\n");
    }

    return 0;
}

sigchld_handler 函数是自定义的信号处理函数，当父进程接收到 SIGCHILD 信号时会调用该函数。

在 sigchld_handler 函数中，使用 waitpid(-1, &status, WNOHANG) 以非阻塞模式回收所有终止的子进程，并根据子进程的退出状态进行相应的输出。

signal(SIGCHLD, sigchld_handler);：将 SIGCHILD 信号的处理方式设置为自定义的信号处理函数。

子进程打印信息，睡眠 2 秒后以状态码 10 退出。

父进程打印信息，睡眠 5 秒后结束。

父进程wait回

收子进程

wait函数是父进程用于等待子进程结束并获取其退出状态的系统调用。当父进程调用wait时，它会阻塞自己，直到有一个子进程结束。wait函数返回子进程的 PID，并通过参数获取子进程的退出状态，这样父进程就可以对结束的子进程进行善后处理，避免产生僵尸进程。

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main() {
    pid_t pid;
    int status;

    // 创建子进程
    pid = fork();

    if (pid < 0) {
        // 处理 fork 失败的情况
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("子进程开始执行，PID: %d\n", getpid());
        sleep(2);  // 模拟子进程执行一段时间
        printf("子进程结束\n");
        exit(10);  // 子进程退出，返回状态码 10
    } else {
        // 父进程代码
        printf("父进程等待子进程结束，子进程 PID: %d\n", pid);
        // 调用 wait 函数等待子进程结束
        pid_t terminated_pid = wait(&status);
        if (terminated_pid > 0) {
            if (WIFEXITED(status)) {
                // 子进程正常退出
                printf("子进程 %d 正常结束，退出状态码: %d\n", terminated_pid, WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
                // 子进程被信号终止
                printf("子进程 %d 被信号 %d 终止\n", terminated_pid, WTERMSIG(status));
            }
        }
    }

    return 0;
}

wait 函数示例

创建子进程：使用 fork 函数创建一个子进程。

子进程：打印信息，睡眠 2 秒，然后以状态码 10 退出。

父进程：调用 wait 函数等待子进程结束。wait 函数会阻塞父进程，直到有一个子进程结束。获取子进程的退出状态后，根据状态判断子进程是正常退出还是被信号终止

WIFEXITED(status)：这个宏用于判断子进程是否是正常终止的。所谓正常终止，指的是子进程通过 return 语句、exit 函数或者 _exit 函数退出。如果子进程是正常终止的，该宏返回非零值；否则返回 0。

WIFSIGNALED(status)：此宏用于判断子进程是否是非正常终止的，也就是子进程是否是被某个信号所终止的。如果子进程是被信号终止的，该宏返回非零值；否则返回 0。

WEXITSTATUS(status)：当子进程正常终止时，使用这个宏可以获取子进程的返回值。需要注意的是，只有在 WIFEXITED(status) 返回非零值时，使用这个宏才有意义。

cpp 复制代码

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

int main() {
    pid_t pid;
    int status;

    // 创建子进程
    pid = fork();

    if (pid < 0) {
        // 处理 fork 失败的情况
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("子进程开始执行，PID: %d\n", getpid());
        // 模拟子进程执行一段时间
        sleep(2);

        // 子进程正常退出，返回状态码 42
        exit(42);
    } else {
        // 父进程代码
        printf("父进程等待子进程结束，子进程 PID: %d\n", pid);
        // 调用 wait 函数等待子进程结束
        pid_t terminated_pid = wait(&status);

        if (terminated_pid > 0) {
            if (WIFEXITED(status)) {
                // 子进程正常退出
                printf("子进程 %d 正常结束，退出状态码: %d\n", terminated_pid, WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
                // 子进程被信号终止
                printf("子进程 %d 被信号 %d 终止\n", terminated_pid, WTERMSIG(status));
            }
        }
    }

    return 0;
}

创建子进程：

使用 fork() 函数创建一个子进程。fork() 函数会返回两次，在父进程中返回子进程的 PID，在子进程中返回 0，如果创建失败则返回 -1。

子进程部分：

子进程打印自身的 PID 信息，然后调用 sleep(2) 模拟执行一段时间。

最后调用 exit(42) 正常退出，并返回状态码 42。

父进程部分：

父进程打印等待子进程结束的信息，然后调用 wait(&status) 函数等待子进程结束。wait 函数会阻塞父进程，直到有一个子进程结束，并将子进程的退出状态存储在 status 变量中。

父进程通过 WIFEXITED(status) 宏判断子进程是否正常退出。由于子进程是通过 exit(42) 正常退出的，所以该宏返回非零值。

在 WIFEXITED(status) 为真的情况下，使用 WEXITSTATUS(status) 宏获取子进程的退出状态码，并将其打印输出。

cpp 复制代码

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

int main() {
    pid_t pid;
    int status;

    // 创建子进程
    pid = fork();

    if (pid < 0) {
        // 处理 fork 失败的情况
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("子进程开始执行，PID: %d\n", getpid());
        // 模拟子进程执行一段时间
        sleep(2);

        // 子进程给自己发送 SIGTERM 信号，模拟被信号终止
        kill(getpid(), SIGTERM);
    } else {
        // 父进程代码
        printf("父进程等待子进程结束，子进程 PID: %d\n", pid);
        // 调用 wait 函数等待子进程结束
        pid_t terminated_pid = wait(&status);

        if (terminated_pid > 0) {
            if (WIFEXITED(status)) {
                // 子进程正常退出
                printf("子进程 %d 正常结束，退出状态码: %d\n", terminated_pid, WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
                // 子进程被信号终止
                printf("子进程 %d 被信号 %d 终止\n", terminated_pid, WTERMSIG(status));
            }
        }
    }

    return 0;
}

子进程在执行一段时间后，调用 kill(getpid(), SIGTERM) 给自己发送 SIGTERM 信号，模拟被信号终止的情况。父进程在子进程结束后，通过 WIFSIGNALED(status) 宏判断子进程是否是被信号终止的，如果是，则使用 WTERMSIG(status) 宏获取终止子进程的信号编号并打印输出。

waitpid介绍

waitpid函数也是用于等待子进程结束的系统调用，它比wait函数更加灵活。waitpid可以指定等待特定 PID 的子进程，也可以设置非阻塞等待模式或者阻塞模式。通过waitpid，父进程可以更精确地控制对子进程的等待和资源回收操作，例如可以在不阻塞父进程的情况下，定期检查子进程是否结束。

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main() {
    pid_t pid;
    int status;

    // 创建子进程
    pid = fork();

    if (pid < 0) {
        // 处理 fork 失败的情况
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("子进程开始执行，PID: %d\n", getpid());
        sleep(2);  // 模拟子进程执行一段时间
        printf("子进程结束\n");
        exit(20);  // 子进程退出，返回状态码 20
    } else {
        // 父进程代码
        printf("父进程等待子进程结束，子进程 PID: %d\n", pid);
        pid_t terminated_pid;
        // 使用 waitpid 函数以非阻塞模式等待子进程结束
        while ((terminated_pid = waitpid(pid, &status, WNOHANG)) == 0) {
            printf("子进程还在运行，父进程继续执行其他任务...\n");
            sleep(1);
        }

        if (terminated_pid > 0) {
            if (WIFEXITED(status)) {
                // 子进程正常退出
                printf("子进程 %d 正常结束，退出状态码: %d\n", terminated_pid, WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
                // 子进程被信号终止
                printf("子进程 %d 被信号 %d 终止\n", terminated_pid, WTERMSIG(status));
            }
        } else if (terminated_pid == -1) {
            perror("waitpid");
        }
    }

    return 0;
}

创建子进程：同样使用 fork 函数创建一个子进程。

子进程：打印信息，睡眠 2 秒，然后以状态码 20 退出。

父进程：使用 waitpid 函数以非阻塞模式（WNOHANG）等待子进程结束。在子进程未结束时，父进程可以继续执行其他任务。当子进程结束后，获取其退出状态并进行相应处理。

竟态初步引入

竞态条件是指当多个进程或线程并发访问共享资源时，由于它们的执行顺序不确定，导致最终结果依赖于它们实际执行顺序的一种现象。在进程编程中，如果多个进程同时对共享资源（如共享内存、文件等）进行读写操作，而没有采取适当的同步机制，就可能出现竞态条件，导致程序运行结果错误。