解密僵尸进程和孤儿进程：如何避免和处理

「爱情、让人受尽委屈。」 2023-10-14 22:14 6阅读 0赞

## 解密僵尸进程和孤儿进程：如何避免和处理 ##

#### 文章目录 ####

*  解密僵尸进程和孤儿进程：如何避免和处理
 *   *  引言
     *   *  简介
         *  目的
     *  什么是僵尸进程
     *   *  定义
         *  形成原因
         *  特征和影响
     *  什么是孤儿进程
     *   *  定义
         *  形成原因
         *  特征和影响
     *  僵尸进程和孤儿进程的区别
     *  如何避免僵尸进程
     *   *  父进程处理SIGCHLD信号
         *  使用wait或waitpid函数
         *  使用守护进程
     *  如何处理僵尸进程
     *   *  使用信号处理函数
         *  使用wait或waitpid函数
         *  使用守护进程
     *  如何避免孤儿进程
     *   *  使用fork函数创建子进程
         *  使用setsid函数创建新会话
     *  如何处理孤儿进程
     *   *  父进程等待子进程结束
         *  使用孤儿进程的父进程处理SIGCHLD信号
     *  总结
     *  参考资料

### 引言 ###

#### 简介 ####

在操作系统中，僵尸进程和孤儿进程是常见的进程状态，它们可能会对系统的稳定性和性能造成影响。了解这两种进程的定义、形成原因以及如何避免和处理它们是每个开发人员和系统管理员必备的知识。

#### 目的 ####

本篇博客将介绍僵尸进程和孤儿进程的概念、区别以及对系统的影响。同时，我们将提供一些实用的方法和技巧，帮助读者避免和处理这两种进程状态，提高系统的稳定性和性能。

### 什么是僵尸进程 ###

#### 定义 ####

僵尸进程是指一个子进程已经终止，但是其父进程还没有调用wait或waitpid函数来获取子进程的终止状态，导致子进程的进程描述符仍然存在于系统进程表中，成为僵尸进程。

#### 形成原因 ####

当一个子进程终止时，内核会向其父进程发送SIGCHLD信号，告知子进程的终止状态。父进程需要调用wait或waitpid函数来处理该信号，否则子进程就会成为僵尸进程。

#### 特征和影响 ####

僵尸进程的特征是在系统进程表中仍然存在，但是无法被调度执行任何任务。僵尸进程占用系统资源，如果大量的僵尸进程积累，可能导致系统资源耗尽，甚至引发系统崩溃。

### 什么是孤儿进程 ###

#### 定义 ####

孤儿进程是指其父进程已经终止或者不存在，但是该子进程仍然在运行的进程。

#### 形成原因 ####

当一个父进程终止时，内核会将其子进程的父进程设置为init进程（进程ID为1），这样这些子进程就成为孤儿进程。

#### 特征和影响 ####

孤儿进程的特征是没有父进程，它们会被init进程接管。孤儿进程不会占用系统资源，但是如果没有正确处理，可能会导致进程资源泄漏或者无法及时回收。

### 僵尸进程和孤儿进程的区别 ###

*  僵尸进程是子进程已经终止但父进程没有处理的进程，而孤儿进程是父进程已经终止但子进程还在运行的进程。
 *  僵尸进程依然占用系统资源，而孤儿进程不会占用系统资源。

### 如何避免僵尸进程 ###

#### 父进程处理SIGCHLD信号 ####

父进程可以注册一个信号处理函数，处理SIGCHLD信号，当子进程终止时，父进程将会收到该信号，然后调用wait或waitpid函数来处理子进程的终止状态，避免子进程变成僵尸进程。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    void sigchld_handler(int signum) {
        
        pid_t pid;
        int status;
    
        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() {
        
        // 注册SIGCHLD信号处理函数
        signal(SIGCHLD, sigchld_handler);
    
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程等待子进程执行...\n");
            sleep(10);
            printf("父进程结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们通过调用`signal`函数注册了一个SIGCHLD信号处理函数`sigchld_handler`。当子进程终止时，父进程会收到SIGCHLD信号，并调用`waitpid`函数来处理子进程的终止状态。如果子进程正常退出，我们可以通过`WIFEXITED`宏和`WEXITSTATUS`宏获取子进程的退出状态码；如果子进程异常终止，我们可以通过`WIFSIGNALED`宏和`WTERMSIG`宏获取子进程的信号编号。

#### 使用wait或waitpid函数 ####

父进程可以通过调用`wait`或`waitpid`函数来等待子进程的终止状态并处理。这两个函数的区别在于`waitpid`函数可以指定等待某个特定的子进程，而`wait`函数等待任意子进程。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程等待子进程执行...\n");
            int status;
            pid_t child_pid = wait(&status);
            
            if (child_pid == -1) {
        
                printf("等待子进程失败\n");
            } else {
        
                if (WIFEXITED(status)) {
        
                    printf("子进程 %d 正常退出，退出状态码：%d\n", child_pid, WEXITSTATUS(status));
                } else if (WIFSIGNALED(status)) {
        
                    printf("子进程 %d 异常终止，信号编号：%d\n", child_pid, WTERMSIG(status));
                }
            }
    
            printf("父进程结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们调用`wait`函数等待子进程的终止状态，并通过`status`参数获取子进程的终止状态。然后我们可以使用`WIFEXITED`宏和`WEXITSTATUS`宏获取子进程的退出状态码，或者使用`WIFSIGNALED`宏和`WTERMSIG`宏获取子进程的信号编号。

#### 使用守护进程 ####

另一种避免僵尸进程的方法是使用守护进程。守护进程是在后台运行的进程，它不会成为僵尸进程的父进程。一种常见的守护进程实现方式是使用`fork`函数创建子进程，并在子进程中调用`setsid`函数创建新的会话。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            setsid(); // 创建新的会话
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们使用`fork`函数创建子进程，并在子进程中调用`setsid`函数创建新的会话。这样子进程就成为了一个守护进程，它不再有父进程，也不会成为僵尸进程。

### 如何处理僵尸进程 ###

#### 使用信号处理函数 ####

我们可以注册一个SIGCHLD信号处理函数，在子进程终止时处理子进程的终止状态。这样可以及时回收僵尸进程的资源。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    void sigchld_handler(int signum) {
        
        pid_t pid;
        int status;
    
        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() {
        
        // 注册SIGCHLD信号处理函数
        signal(SIGCHLD, sigchld_handler);
    
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程执行中...\n");
            sleep(10);
            printf("父进程执行结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们通过调用`signal`函数注册了一个SIGCHLD信号处理函数`sigchld_handler`。当子进程终止时，父进程会收到SIGCHLD信号，并在信号处理函数中调用`waitpid`函数来处理子进程的终止状态。在循环中，我们使用`WNOHANG`选项来非阻塞地等待子进程的终止状态，以便能够及时处理多个子进程的终止状态。

#### 使用wait或waitpid函数 ####

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程执行中...\n");
            int status;
            pid_t child_pid = wait(&status);
            
            if (child_pid == -1) {
        
                printf("等待子进程失败\n");
            } else {
        
                if (WIFEXITED(status)) {
        
                    printf("子进程 %d 正常退出，退出状态码：%d\n", child_pid, WEXITSTATUS(status));
                } else if (WIFSIGNALED(status)) {
        
                    printf("子进程 %d 异常终止，信号编号：%d\n", child_pid, WTERMSIG(status));
                }
            }
    
            printf("父进程执行结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

#### 使用守护进程 ####

另一种处理僵尸进程的方法是使用守护进程。守护进程是在后台运行的进程，它不会成为僵尸进程的父进程。一种常见的守护进程实现方式是使用`fork`函数创建子进程，并在子进程中调用`setsid`函数创建新的会话。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            setsid(); // 创建新的会话
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程执行中...\n");
            sleep(10);
            printf("父进程执行结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们使用`fork`函数创建子进程，并在子进程中调用`setsid`函数创建新的会话。这样子进程就成为了一个守护进程，它不再有父进程，也不会成为僵尸进程。通过创建守护进程，我们可以避免僵尸进程的产生。

### 如何避免孤儿进程 ###

#### 使用fork函数创建子进程 ####

为了避免孤儿进程的产生，我们可以使用`fork`函数创建子进程，并在父进程中等待子进程执行完毕。这样可以确保子进程有父进程，避免成为孤儿进程。下面是一个示例代码：

在上面的示例代码中，我们使用`fork`函数创建子进程，并在父进程中调用`wait`函数等待子进程执行完毕。通过这种方式，我们确保了子进程有父进程，避免了孤儿进程的产生。

#### 使用setsid函数创建新会话 ####

另一种避免孤儿进程的方法是使用`fork`函数创建子进程，并在子进程中调用`setsid`函数创建新的会话。这样子进程就会脱离原有的会话组，成为一个新的会话的领导进程，也就不会成为孤儿进程。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            setsid(); // 创建新的会话
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们使用`fork`函数创建子进程，并在子进程中调用`setsid`函数创建新的会话。这样子进程就成为了一个新的会话的领导进程，不再有父进程，也不会成为孤儿进程。

### 如何处理孤儿进程 ###

#### 父进程等待子进程结束 ####

如果出现孤儿进程，父进程可以通过等待子进程结束来处理。父进程可以调用`wait`或`waitpid`函数等待子进程的终止状态，并处理子进程的退出状态码。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程```c
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            printf("父进程等待子进程执行...\n");
            sleep(10);
            printf("父进程结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，父进程通过调用`wait`函数等待子进程的终止状态，并处理子进程的退出状态码。在等待子进程结束时，父进程可以进行其他的操作，然后在合适的时机结束。

#### 使用孤儿进程的父进程处理SIGCHLD信号 ####

另一种处理孤儿进程的方法是让孤儿进程的父进程处理SIGCHLD信号。当子进程终止时，内核会向其父进程发送SIGCHLD信号，父进程可以注册一个信号处理函数来处理该信号，并在处理函数中调用`wait`或`waitpid`函数来处理子进程的终止状态。下面是一个示例代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    void sigchld_handler(int signum) {
        
        pid_t pid;
        int status;
    
        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() {
        
        pid_t pid = fork();
    
        if (pid == 0) {
        
            // 子进程
            printf("子进程执行中...\n");
            sleep(5);
            printf("子进程执行结束\n");
            exit(0);
        } else if (pid > 0) {
        
            // 父进程
            signal(SIGCHLD, sigchld_handler); // 注册SIGCHLD信号处理函数
            printf("父进程执行中...\n");
            sleep(10);
            printf("父进程执行结束\n");
        } else {
        
            // fork失败
            printf("fork失败\n");
            exit(1);
        }
    
        return 0;
    }

在上面的示例代码中，我们注册了一个SIGCHLD信号处理函数`sigchld_handler`，当子进程终止时，父进程会收到SIGCHLD信号，并在信号处理函数中调用`waitpid`函数来处理子进程的终止状态。通过这种方式，孤儿进程的父进程可以及时处理子进程的终止状态。

### 总结 ###

本篇博客介绍了僵尸进程和孤儿进程的概念、形成原因以及对系统的影响。我们提供了一些实用的方法和技巧，帮助读者避免和处理这两种进程状态，提高系统的稳定性和性能。通过正确处理SIGCHLD信号、使用wait或waitpid函数以及创建守护进程，我们可以避免僵尸进程的产生。而通过使用fork函数创建子进程并等待子进程结束，或者让孤儿进程的父进程处理SIGCHLD信号，我们可以避免孤儿进程的产生。通过了解和应用这些方法，我们可以更好地管理进程，确保系统的稳定运行。

### 参考资料 ###

*  [The Linux Programming Interface][]
 *  [Advanced Programming in the UNIX Environment][]

[The Linux Programming Interface]: https://man7.org/tlpi/
[Advanced Programming in the UNIX Environment]: https://www.apuebook.com