孤儿进程与僵尸进程

　　本文测试程序和图片及部分文字摘录自博文孤儿进程与僵尸进程[总结]。

基本概念

　　孤儿进程和僵死进程的概念如下：

　　孤儿进程：一个父进程退出、但其仍在运行的孤儿进程。孤儿进程将被init进程（进程号为1）所收养，并由init进程对它们完成状态收集工作。

　　僵尸进程：一个已经终止、但是其父进程尚未对其进行善后处理（获取终止子进程的有关信息，释放它仍占用的资源）的进程。

　　我们知道在unix/linux中，正常情况下，子进程是通过父进程创建的。子进程的结束和父进程的运行是一个异步过程，即父进程永远无法预测子进程到底什么时候结束。 当一个进程终止之后，它的父进程需要调用wait()或者waitpid()函数取得子进程的终止状态。

　　设置僵死状态的目的是维护子进程的信息，以便父进程在以后某个时候获取。这些信息包括了子进程的进程ID、终止状态以及资源利用信息（CPU时间、内存使用量等等）。如果一个进程终止（使其所有子进程变成孤儿进程），而该进程有子进程处于僵死状态，那么它的所有僵死子进程的父进程ID将被重置为1（init进程）。继承这些子进程的init进程将清理它们（也就是init进程将wait它们，从而除去它们的僵死状态）。

问题及危害

　　Unix/Linux提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息，就可以得到。这种机制就是: 在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等， 但是仍然为其保留一定的信息(包括进程号the process ID、退出状态the termination status of the process、运行时间the amount of CPU time taken by the process等)，直到父进程通过wait / waitpid来取时才释放。 这样就导致了问题，如果进程不调用wait / waitpid的话，那么保留的那段信息就不会释放，其进程号就会一直被占用。但是系统所能使用的进程号是有限的，大量产生的僵尸进程将导致系统不能产生新的进程。此即为僵尸进程的危害，应当避免。

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

测试

孤儿进程

　　测试程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>

int main()
{
    pid_t pid;
    //创建一个进程
    pid = fork();
    //创建失败
    if (pid < 0)
    {
        perror("fork error:");
        exit(0);
    }
    //子进程
    if (pid == 0)
    {
        printf("I am the child process.
");
        //输出进程ID和父进程ID
        printf("pid: %d	ppid:%d
", getpid(), getppid());
        printf("I will sleep for five seconds.
");
        //睡眠5s，保证父进程先退出
        sleep(5);
        printf("pid: %d	ppid:%d
", getpid(), getppid());
        printf("Child process exited.
");
    }
    //父进程
    else
    {
        printf("I am the father process.
");
        //父进程睡眠1s，保证子进程输出进程id
        sleep(1);
        printf("Father process exited.
");
    }
    exit(0);
}

　　测试结果如下：

　　

僵尸进程

　　1. 简单测试

　　测试程序如下：

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

int main()
{
    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fork error:");
        exit(1);
    }
    else if (pid == 0)
    {
        printf("I am the child process. I existed.
");
        exit(0);
    }
    printf("I am the father process.I will sleep for two seconds
");
    //等待子进程先退出
    sleep(2);
    //输出进程信息
    system("ps -o pid,ppid,state,tty,command");
    printf("Father process exited.
");
    exit(0);
}

　　测试结果如下所示：

　　

　　2. 父进程循环创建子进程

　　测试程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

int main()
{
    pid_t  pid;
    //循环创建子进程
    while(1)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork error:");
            exit(1);
        }
        else if (pid == 0)
        {
            printf("I am a child process.
I am exiting.
");
            //子进程退出，成为僵尸进程
            exit(0);
        }
        else
        {
            //父进程休眠20s继续创建子进程
            sleep(20);
            continue;
        }
    }
    return 0;
}

　　程序测试结果如下所示：

　　

僵尸进程解决方法

POSIX信号处理

　　信号（signal）就是告知某个进程发生了某个事件的通知，有时也称为软件中断（software interrupt）。信号通常是异步发生的，也就是说进程预先不知道信号的准确发生时刻。

　　信号可以：

　　1）由一个进程发给另一个进程（或自身）；　　

　　2）有内核发给某个进程。

　　例如，SIGCHLD信号就是由内核在任何一个进程终止时发给它的父进程的一个信号。

　　每个信号都有一个与之关联的处置（disposition），也称为行为（action）。我们通过调用sigaction函数来设定一个信号的处置，并有三种选择：

　　1）我们可以提供一个函数，只要有特定信号发生时它就被调用。这样的函数称为信号处理函数（signal handler），这种行为称为捕获（catching）信号。有两个信号不能被捕获，它们是SIGKILL和SIGSTOP。信号处理函数由信号值这个单一的整数参数来调用，且没有返回值，其函数原型为：

void handler(int signo);

对于大多数信号来说，调用sigaction函数并指定信号发生时所调用的函数就是捕获信号所需做的全部工作。

　　2）我们可以把某个信号的处置设定为SIG_IGN来忽略（ignore）它。SIGKILL和SIGSTOP这两个信号不能忽略。

　　3）我们可以把某个信号的处置设置为SIG_DFL来启用它的默认（default）处置。默认处置是在收到信号后终止进程，其中某些信号还在当前目录产生一个进程的核心映像（core image，也称为内存映像）。

　　signal函数

　　建立信号处置的POSIX方法就是调用sigaction函数。不过这有点复杂，因为该函数的参数之一是我们必须分配并填写的结构。简单些的方法就是调用signal函数，其第一个参数是信号名，第二个参数或为指向函数的指针，或为常值SIG_IGN和SIG_DFL。

法一：通过信号机制

　　1. wait及waitpid函数介绍

#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);
// 返回：若成功则返回进程ID，若出错则返回-1

　　这两个函数的statloc是一个整形指针。如果statloc不是一个空指针，则终止进程的终止信息就存放在它所指向的单元内。如果不关心终止状态，则可将该参数指定为空指针。

　　这两个函数的区别在于：

　　1）在一个子进程终止前，wait使其调用者阻塞，而waitpid有一个选项，可使调用者不阻塞。

　　2）waitpid并不等待在其调用之后的第一个终止子进程，它有若干个选项，可以控制它所等待的进程。

　　对于waitpid函数：

　　　　pid参数：

　　　　　　pid == -1，等待任一子进程。就这一方面而言，waitpid与wait等效；

　　　　　　pid > 0，等待期进程ID与pid相等的子进程；

　　　　　　pid == 0，等待其组ID等于调用进程组ID的任一子进程；

　　　　　　pid < 0，等待其组ID等于pid绝对值的任一子进程。

　　　　options参数：

　　　　　　WCONTINUED，若实现支持作业控制，那么由pid指定的任一子进程在暂停后已经继续，但其尚未报告，则返回其状态。

　　　　　　WNOHANG，若由pid指定的子进程并不是立即可用的，则waitpid不阻塞，此时其返回值为0。

　　　　　　WUNTRACED，若某实现支持作业控制，而由pid指定的任一子进程已处于暂停状态，并且其状态自暂停以来还未报告过，则返回其状态。WIFSTOPPED宏确定返回值是否对应于一个暂停子进程。

　　一个常见的用于防止僵尸进程的方法如下程序：

// 父线程程序中 创建捕捉子进程退出信号
signal(SIGCHLD,sig_child);
... ...
// 定义信号处理函数
void sig_child(int signo)
{
     pid_t pid;
     int stat;
     //处理僵尸进程
     while ((pid = waitpid(-1, &stat, WNOHANG)) >0)
            printf("child %d terminated.
", pid);
}

　　

　　2. 测试程序

　　子进程退出时向父进程发送SIGCHILD信号，父进程处理SIGCHILD信号。在信号处理函数中调用wait进行处理僵尸进程。测试程序如下所示：

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>

static void sig_child(int signo);

int main()
{
    pid_t pid;
    //创建捕捉子进程退出信号
    signal(SIGCHLD,sig_child);
    pid = fork();
    if (pid < 0)
    {
        perror("fork error:");
        exit(1);
    }
    else if (pid == 0)
    {
        printf("I am child process,pid id %d.I am exiting.
",getpid());
        exit(0);
    }
    printf("I am father process.I will sleep two seconds
");
    //等待子进程先退出
    sleep(2);
    //输出进程信息
    system("ps -o pid,ppid,state,tty,command");
    printf("father process is exiting.
");
    return 0;
}

static void sig_child(int signo)
{
     pid_t        pid;
     int        stat;
     //处理僵尸进程
     while ((pid = waitpid(-1, &stat, WNOHANG)) >0)
            printf("child %d terminated.
", pid);
}

　　测试结果如下所示：

　　

法二：fork两次

　　《Unix 环境高级编程》8.6节说的非常详细。原理是将子进程成为孤儿进程，从而其的父进程变为init进程，通过init进程可以处理僵尸进程。测试程序如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

int main()
{
    pid_t  pid;
    //创建第一个子进程
    pid = fork();
    if (pid < 0)
    {
        perror("fork error:");
        exit(1);
    }
    //第一个子进程
    else if (pid == 0)
    {
        //子进程再创建子进程
        printf("I am the first child process.pid:%d	ppid:%d
",getpid(),getppid());
        pid = fork();
        if (pid < 0)
        {
            perror("fork error:");
            exit(1);
        }
        //第一个子进程退出
        else if (pid >0)
        {
            printf("first procee is exited.
");
            exit(0);
        }
        //第二个子进程
        //睡眠3s保证第一个子进程退出，这样第二个子进程的父亲就是init进程里
        sleep(3);
        printf("I am the second child process.pid: %d	ppid:%d
",getpid(),getppid());
        exit(0);
    }
    //父进程处理第一个子进程退出
    if (waitpid(pid, NULL, 0) != pid)
    {
        perror("waitepid error:");
        exit(1);
    }

    return 0;
}

　　测试结果如下图所示：

　　

法三：关掉僵死进程的父进程

　　很明显这种方法是可以解决僵死子进程的，但在实际可能没多大用处，因为如果父进程正好在工作，我们是不大可能就关掉该父进程的。

参考资料

　　《UNIX高级环境编程》

　　《UNIX网络编程 卷1》

　　孤儿进程与僵尸进程[总结]