孤儿进程与僵尸进程以及僵尸进程的解决

孤儿进程：

定义： 父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（ Orphan Process ）。

过程： 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init 进程会循环地 wait() 它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候， init 进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

这个 init 就是pid为1的进程。(实际情况可能因特定的系统实现或环境而有所不同 )

由上面的过程可以得出结论：孤儿进程没有什么危害。

下面给出测试孤儿进程的测试代码：

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

int main() {

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

    // 判断是父进程还是子进程
    if(pid > 0) {

        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());

    } else if(pid == 0) {
        sleep(1);
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }

    return 0;
}

执行结果如下：

我使用的是子系统，所以 init 的 pid 可能不为1。

观察上图也可以看到确实由 pid 为31的 init 进程。

还有一点需要注意的是：执行结果那里输出完父进程的结果，然后就将这个终端(父进程中输出的 ppid )切换到前台了。因为终端只知道父进程运行完了，不知道子进程还在运行，所以在输出子进程数据的时候终端前台出来了。(运行都是在后台的，输出在同一终端是因为父进程和子进程内核区有一些数据是共享的)

僵尸进程：

定义：

每个进程结束之后 , 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法自己释放掉，需要父进程去释放。

进程终止时，父进程尚未回收，子进程残留资源（ PCB ）存放于内核中，变成僵尸（ Zombie ）进程。

僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用 wait() 或 waitpid( ) 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

下面给出测试僵尸进程的测试代码：

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

int main() {

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

    // 判断是父进程还是子进程
    if(pid > 0) {
        while(1) {
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
            sleep(1);
        }

    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }

    return 0;
}

执行结果如下：

打开另一个终端发现，子进程为僵尸进程，并且这个进程使用kill - 9是杀不掉的。

如何解决僵尸进程：

进程回收：

1. 在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块 PCB 的信息（包括进程号、退出状态、运行时间等）。

2. 父进程可以通过调用 wait 或 waitpid 得到它的退出状态同时彻底清除掉这个进程。

3. wait() 和 waitpid() 函数的功能一样，区别在于， wait() 函数会阻塞， waitpid() 可以设置不阻塞， waitpid() 还可以指定等待哪个子进程结束。

注意：一次 wait 或 waitpid 调用只能清理一个子进程，清理多个子进程应使用循环。

退出信息相关宏函数：

WIFEXITED ( status ) 非 0 ，进程正常退出。

WEXITSTATUS ( status ) 如果上宏为真，获取进程退出的状态（ exit 的参数）。

WIFSIGNALED ( status ) 非 0 ，进程异常终止。

WTERMSIG ( status ) 如果上宏为真，获取使进程终止的信号编号。

WIFSTOPPED ( status ) 非 0 ，进程处于暂停状态。

WSTOPSIG ( status ) 如果上宏为真，获取使进程暂停的信号的编号。

WIFCONTINUED ( status ) 非 0 ，进程暂停后已经继续运行。

wait()：

下面给出解决僵尸进程的代码：

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *wstatus);
        功能：等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收子进程的资源。
        参数：int *wstatus
            进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
        返回值：
            - 成功：返回被回收的子进程的id
            - 失败：-1 (所有的子进程都结束，调用函数失败)

    调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
    如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.

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


int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {// 子进程不需要继续产生子进程了
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());
            // int ret = wait(NULL);
            int st;
            int ret = wait(&st);// 获取子进程退出的状态
            if(ret == -1) {
                break;
            }
            if(WIFEXITED(st)) {
                // 是不是正常退出
                printf("退出的状态码：%d\n", WEXITSTATUS(st));
            }
            if(WIFSIGNALED(st)) {
                // 是不是异常终止
                printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
            }
            printf("child die, pid = %d\n", ret);
            sleep(1);
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }

        exit(0);
    }

    return 0; // exit(0)
}

在测试正常退出的时候要记得把子进程中的while循环注释掉。

输出结果如下：

使用信号杀死子进程的输出结果为：

waitpid()：

测试代码如下：

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid, int *wstatus, int options);
        功能：回收指定进程号的子进程，可以设置是否阻塞。
        参数：
            - pid:
                pid > 0 : 某个子进程的pid
                pid = 0 : 回收当前进程组的所有子进程  (一个进程是这个组的组长，那么这个进程组的pgid就是该进程的pid)  
                pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）(在别的组的子进程也回收)
                pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
            - options：设置阻塞或者非阻塞
                0 : 阻塞
                WNOHANG : 非阻塞
            - 返回值：
                > 0 : 返回子进程的id
                = 0 : options=WNOHANG, 表示还有子进程活着(在非阻塞的情况下才有可能返回0)
                = -1 ：错误，或者没有子进程了
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());
            sleep(1);

            int st;
            // int ret = waitpid(-1, &st, 0);
            int ret = waitpid(-1, &st, WNOHANG);

            if(ret == -1) {
                break;
            } else if(ret == 0) {
                // 说明还有子进程存在
                continue;
            } else if(ret > 0) {

                if(WIFEXITED(st)) {
                    // 是不是正常退出
                    printf("退出的状态码：%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
                    // 是不是异常终止
                    printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                }

                printf("child die, pid = %d\n", ret);
            }
           
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }
        exit(0);
    }

    return 0; 
}

非阻塞执行结果如下：