《Linux/UNIX系统编程手册》第26章 监控子进程

关键词：wait()、waitpid()、WIFEXITED/WIFSIGNALED/WIFSTOPPED/WIFCONTINUED、waitid()、wait3()/wait4()、SIGCHLD等等。

1. 等待子进程

对于需要创建子进程的应用来说，父进程能够检测子进程的终止时间和过程是很有必要的。

1.1 系统调用wait()

系统调用wait()等待调用进程的任一子进程终止，同时在参数status所指向的缓冲区中返回该子进程的终止状态。

#include <sys/wait.h>
pid_t wait(int *status);
　　Returns process ID of terminated child, or –1 on error

• 如果调用进程并无之前未被等待的子进程终止，调用将一直阻塞，直至某个子进程终止。如果调用时已有子进程终止，wait()则立即返回。
• 如果status非空，那么关于子进程如何终止的信息则会通过status指向的整型变量返回。
• 内核将会为父进程下所有紫禁城的运行总量追加进程CPU时间以及资源使用数据。
• 将终止子进程的ID作为wait()的结果返回。

int
main(int argc, char *argv[])
{
    int numDead;       /* Number of children so far waited for */
    pid_t childPid;    /* PID of waited for child */
    int j;

    if (argc < 2 || strcmp(argv[1], "--help") == 0)
        usageErr("%s sleep-time...
", argv[0]);

    setbuf(stdout, NULL);           /* Disable buffering of stdout */

    for (j = 1; j < argc; j++) {    /* Create one child for each argument */
        switch (fork()) {
        case -1:
            errExit("fork");

        case 0:                     /* Child sleeps for a while then exits */------------创建子进程。
            printf("[%s] child %d started with PID %ld, sleeping %s "
                    "seconds
", currTime("%T"), j, (long) getpid(),
                    argv[j]);
            sleep(getInt(argv[j], GN_NONNEG, "sleep-time"));
            _exit(EXIT_SUCCESS);

        default:                    /* Parent just continues around loop */
            break;
        }
    }

    numDead = 0;
    for (;;) {                      /* Parent waits for each child to exit */
        childPid = wait(NULL);-----------------------------------------------------------阻塞在此，知道由子进程退出。
        if (childPid == -1) {------------------------------------------------------------出错时，wait()返回-1。可能原因是调用进程并无未被等待的子进程，此时errno置为ECHILD。
            if (errno == ECHILD) {
                printf("No more children - bye!
");
                exit(EXIT_SUCCESS);
            } else {                /* Some other (unexpected) error */
                errExit("wait");
            }
        }

        numDead++;
        printf("[%s] wait() returned child PID %ld (numDead=%d)
",
                currTime("%T"), (long) childPid, numDead);
    }
}

运行结果如下：

al@al-B250-HD3:~/tlpi/procexec$ ./multi_wait 6 5 4 3 2 1 0
[11:22:26] child 2 started with PID 25439, sleeping 5 seconds------------------启动7个子进程。
[11:22:26] child 4 started with PID 25441, sleeping 3 seconds
[11:22:26] child 3 started with PID 25440, sleeping 4 seconds
[11:22:26] child 5 started with PID 25442, sleeping 2 seconds
[11:22:26] child 6 started with PID 25443, sleeping 1 seconds
[11:22:26] child 1 started with PID 25438, sleeping 6 seconds
[11:22:26] child 7 started with PID 25444, sleeping 0 seconds
[11:22:26] wait() returned child PID 25444 (numDead=1)-------------------------子进程依次退出，主进程捕捉到。
[11:22:27] wait() returned child PID 25443 (numDead=2)
[11:22:28] wait() returned child PID 25442 (numDead=3)
[11:22:29] wait() returned child PID 25441 (numDead=4)
[11:22:30] wait() returned child PID 25440 (numDead=5)
[11:22:31] wait() returned child PID 25439 (numDead=6)
[11:22:32] wait() returned child PID 25438 (numDead=7)
No more children - bye!--------------------------------------------------------所有子进程退出后，wait()返回-1。

1.2 系统调用waitpid()

 waitpid()相对于wait()有如下优势：

如果父进程已经创建了多个子进程，使用wait()将无法等待等待某个特定子进程的完成，只能按顺序等待下一个子进程的终止。

如果没有子进程退出，wait()总是保持阻塞。有时候会希望执行非阻塞的等待。

使用wait()只能发现那些已经终止的子进程。对于子进程因某个信号而停止，或是已停止子进程收到SIGCONT信号后恢复执行的情况就无能为力了。

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
    Returns process ID of child, 0 (see text), or –1 on error

status意义和wait()相同。

pid用来表示需要等待的具体子进程：

如果pid大于0，表示等待进程ID为pid的子进程。

如果pid等于0，则等待与调用进程同一个进程组的所有子进程。

如果pid等于-1，则会等待任意子进程。wait(&status)与waitpid(-1, &status, 0)等价。

如果pid小于-1，则会等待进程组标识符与pid绝对值相等的所有子进程。

参数options是一个位掩码，可以包含0个或多个如下标志：

WUNTRACED：除了返回终止子进程的信息外，还返回因信号而停止的子进程信息。

WCONTINUED：返回那些因收到SIGCONT信号而恢复执行的已停止子进程的状态信息。

WNOHANG：如果参数pid所指定的子进程并未发生状态改变，则立即返回，而不会阻塞，亦即poll；waitpid()返回0,如果调用进程并无与pid匹配的子进程，则waitpid()报错，将错误号置为ECHILD。

1. 3 等待状态值

由wait()和waitpid()返回的status值，可用来区分一下子进程事件。

子进程调用_exit()或者exit()而终止，并制定一个整型值作为退出装填。

子进程收到未处理信号而终止。

子进程因为信号而停止，并以WUNTRACED标志调用waitpid()。

子进程因收到信号SIGCONT而恢复，并以WCONTINUED标志调用waitpid()。

status为整型变量，但是实际只使用了其最低的2个字节。

头文件<sys/wait.h>中定义了用于解析等待状态值的一组标准宏。对自wait()或waitpid()返回的status值进行处理。

WIFEXITED(staus)：若子进程正常结束则返回true。此时，可以通过WEXITSTATUS(status)返回子进程的退出状态。

WIFSIGNALED(status)：若子进程是被信号杀掉则返回真。此时，可以通过WTERMSIG(status)返回导致子进程终止的信号编号。若子进程产生内核转储文件，则宏WCOREDUMP(status)返回真。

WIFSTOPPED(status)：若子进程因信号而停止，则返回真。此时，WSTOPSIG(status)返回导致子进程停止的信号编号。

WIFCONTINUED(status)：若子进程收到SIGCONT而恢复执行，则返回真。

#include <sys/wait.h>
#include "print_wait_status.h"          /* Declares printWaitStatus() */
#include "tlpi_hdr.h"

int
main(int argc, char *argv[])
{
    int status;
    pid_t childPid;

    if (argc > 1 && strcmp(argv[1], "--help") == 0)
        usageErr("%s [exit-status]
", argv[0]);

    switch (fork()) {
    case -1: errExit("fork");

    case 0:             /* Child: either exits immediately with given
                           status or loops waiting for signals */
        printf("Child started with PID = %ld
", (long) getpid());
        if (argc > 1)                   /* Status supplied on command line? */
            exit(getInt(argv[1], 0, "exit-status"));-----------------------------直接以退出码argv[1]退出。
        else                            /* Otherwise, wait for signals */
            for (;;)
                pause();---------------------------------------------------------等待信号退出。
        exit(EXIT_FAILURE);             /* Not reached, but good practice */

    default:            /* Parent: repeatedly wait on child until it
                           either exits or is terminated by a signal */
        for (;;) {
            childPid = waitpid(-1, &status, WUNTRACED
#ifdef WCONTINUED       /* Not present on older versions of Linux */
                                                | WCONTINUED
#endif
                    );-----------------------------------------------------------等待进程组标识符与当前进程pid绝对值相等的所有子进程。
            if (childPid == -1)
                errExit("waitpid");----------------------------------------------返回-1表示错误。

            /* Print status in hex, and as separate decimal bytes */

            printf("waitpid() returned: PID=%ld; status=0x%04x (%d,%d)
",
                    (long) childPid,
                    (unsigned int) status, status >> 8, status & 0xff);
            printWaitStatus(NULL, status);---------------------------------------打印status返回信息。

            if (WIFEXITED(status) || WIFSIGNALED(status))
                exit(EXIT_SUCCESS);
        }
    }
}

printWaitStatus()解析status，并输出可读性文本。

void                    /* Examine a wait() status using the W* macros */
printWaitStatus(const char *msg, int status)
{
    if (msg != NULL)
        printf("%s", msg);

    if (WIFEXITED(status)) {---------------------------------------status低8位为0，表示正常终止。退出状态在高8位。
        printf("child exited, status=%d
", WEXITSTATUS(status));

    } else if (WIFSIGNALED(status)) {------------------------------低7位为终止信号，高8位未用。
        printf("child killed by signal %d (%s)",
                WTERMSIG(status), strsignal(WTERMSIG(status)));
#ifdef WCOREDUMP        /* Not in SUSv3, may be absent on some systems */
        if (WCOREDUMP(status))-------------------------------------bit7表示是否core dumped。
            printf(" (core dumped)");
#endif
        printf("
");

    } else if (WIFSTOPPED(status)) {-------------------------------低8位为0x7f表示被信号所终止，高8位。
        printf("child stopped by signal %d (%s)
",
                WSTOPSIG(status), strsignal(WSTOPSIG(status)));

#ifdef WIFCONTINUED     /* SUSv3 has this, but older Linux versions and
                           some other UNIX implementations don't */
    } else if (WIFCONTINUED(status)) {-----------------------------status为0xffff表示通过信号恢复执行。
        printf("child continued
");
#endif

    } else {            /* Should never happen */
        printf("what happened to this child? (status=%x)
",
                (unsigned int) status);
    }
}

正常退出：

./child_status 128
Child started with PID = 22743
waitpid() returned: PID=22743; status=0x8000 (128,0)---------返回值status为0x8000，低8位为0；高8位为0x80，返回值为128。
child exited, status=128

为信号所杀：

./child_status &
[1] 22748
al@al-B250-HD3:~/tlpi/procexec$ Child started with PID = 22749al@al-B250-HD3:~/tlpi/procexec$ kill -SIGILL 22749
al@al-B250-HD3:~/tlpi/procexec$ waitpid() returned: PID=22749; status=0x0084 (0,132)--------status为0x0084，低8位为0x84，bit7位1表示core dumped，信号为4表示SIGILL;高8位为0x00。
child killed by signal 4 (Illegal instruction) (core dumped)

1.4 从信号处理程序中终止进程

 默认情况下某些信号会终止进程，如果希望在进程终止之前执行一些清理步骤。可以设置一个处理程序来捕获这些信号，清理完之后再终止进程。

void handler(int sig)
{
  /* Perform cleanup steps */
  signal(sig, SIG_DFL); /* Disestablish handler */
  raise(sig); /* Raise signal again */
}

1.5 系统调用waitid()

waitid()返回子进程的状态，相对于waitpid()提供了扩展功能。

#include <sys/wait.h>
int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
    Returns 0 on success or if WNOHANG was specified and there were no children to wait for, or –1 on error

 参数idtype和id指定需要等待哪些子进程：

• 如果idtype为P_ALL，则等待任何子进程，同时忽略id值。
• 如果idtype为P_PID，则等待进程ID为id进程的子进程。
• 如果idtype为P_PGID，则等待进程组ID为id给进程的所有子进程。

waitid()通过options提供更为精确控制：

WEXITED：等待已终止的子进程，而无论其是否正常返回。

WSTOPPED：等待已通过信号而停止的子进程。

WCONTINUED：等待经由信号SIGCONT而恢复的子进程。

 WNOHANG：如果参数pid所指定的子进程并未发生状态改变，则立即返回，而不会阻塞，亦即poll；waitpid()返回0,如果调用进程并无与pid匹配的子进程，则waitpid()报错，将错误号置为ECHILD。

WNOWAIT：如果指定了WNOWAIT，则会返回子进程状态，但子进程依然处于可等待的状态，稍后可在此等待并获取相同信息。

执行成功waitid()返回0，且会更新指针infop所指向的siginfo_t结构，已包含子进程的相关信息。

结构siginfo_t字段如下：

1.6 系统调用wait3()和wait4()

系统调用wait3()和wait4()执行与waitpid()类似的工作，主要差别在于参数rusage所指向的结构中返回终止子进程的资源使用情况。

#define _BSD_SOURCE /* Or #define _XOPEN_SOURCE 500 for wait3() */
#include <sys/resource.h>
#include <sys/wait.h>
pid_t wait3(int *status, int options, struct rusage *rusage);
pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage);
　　Both return process ID of child, or –1 on error

struct rusage结构如下：

struct    rusage {
    struct timeval ru_utime;    /* user time used */
    struct timeval ru_stime;    /* system time used */
    __kernel_long_t    ru_maxrss;    /* maximum resident set size */
    __kernel_long_t    ru_ixrss;    /* integral shared memory size */
    __kernel_long_t    ru_idrss;    /* integral unshared data size */
    __kernel_long_t    ru_isrss;    /* integral unshared stack size */
    __kernel_long_t    ru_minflt;    /* page reclaims */
    __kernel_long_t    ru_majflt;    /* page faults */
    __kernel_long_t    ru_nswap;    /* swaps */
    __kernel_long_t    ru_inblock;    /* block input operations */
    __kernel_long_t    ru_oublock;    /* block output operations */
    __kernel_long_t    ru_msgsnd;    /* messages sent */
    __kernel_long_t    ru_msgrcv;    /* messages received */
    __kernel_long_t    ru_nsignals;    /* signals received */
    __kernel_long_t    ru_nvcsw;    /* voluntary context switches */
    __kernel_long_t    ru_nivcsw;    /* involuntary " */
};

wait3()和wait4()的区别在于，wait3()等待任意子进程，wait4()可以用于等待选定的一个或多个子进程。

除了获取rusage信息外，wait3()等同于waitpid(-1, &status, options)；wait4()等同于wiatpid(pid, &status, options)。

UNIX中，wait3()和wait4()返回已终止子进程的资源使用情况；对于Linux，如果在options中指定WUNTRACED选项，则还可以获取到停止子进程的资源使用信息。

PS：这两系统调用可移植性较差。

2. 孤儿进程与僵尸进程

谁是孤儿子进程的父进程？

进程ID为1的init进程是众进程之祖，init会接管孤儿进程。

父进程执行wait()之前，其子进程就已经终止，这将会发生什么？

即使子进程已经结束，系统任然允许其父进程在之后的某一时刻执行wait()。该进程所唯一保留的是内核进程表中的一条记录，其中包含子进程ID、终止状态、资源使用情况等。

父进程执行wait()之后，由于不再需要子进程所剩余的最后信息，内核将删除僵尸进程。如果父进程未执行wait()随即退出，那么init进程将接管子进程并自动调用wait()，从系统中移除僵尸进程。

僵尸进程

如果父进程创建了某一子进程，但并未执行wait()，那么内核进程表中降为盖子进程永久保留一条记录。如果存在大量僵尸进程，势必将填满内核进程表，从而阻碍新进程的创建。

既然无法用新号杀死僵尸进程，那么从系统中移除的唯一方法就是杀掉它的父进程，此时init进程将接管和等待这些僵尸进程，从而从系统中将他们清理掉。

#include <signal.h>
#include <libgen.h>             /* For basename() declaration */
#include "tlpi_hdr.h"

#define CMD_SIZE 200

int
main(int argc, char *argv[])
{
    char cmd[CMD_SIZE];
    pid_t childPid;

    setbuf(stdout, NULL);       /* Disable buffering of stdout */

    printf("Parent PID=%ld
", (long) getpid());

    switch (childPid = fork()) {
    case -1:
        errExit("fork");

    case 0:     /* Child: immediately exits to become zombie */
        printf("Child (PID=%ld) exiting
", (long) getpid());
        _exit(EXIT_SUCCESS);----------------------------------------子进程打印一条消息后，立即退出。此时变成了僵尸进程。

    default:    /* Parent */
        sleep(3);               /* Give child a chance to start and exit */
        snprintf(cmd, CMD_SIZE, "ps | grep %s", basename(argv[0]));
        system(cmd);            /* View zombie child */-------------等待子进程变成僵尸进程，ps查看进程情况。

        /* Now send the "sure kill" signal to the zombie */

        if (kill(childPid, SIGKILL) == -1)--------------------------发送SIGKILL信号杀死僵尸子进程。
            errMsg("kill");
        sleep(3);               /* Give child a chance to react to signal */
        printf("After sending SIGKILL to zombie (PID=%ld):
", (long) childPid);
        system(cmd);            /* View zombie child again */-------等待SIGKILL信号发送到僵尸子进程，并作出反应。

        exit(EXIT_SUCCESS);
    }
}

使用如下命令执行结果如下：

./make_zombie && ps -a | grep make_zombile
Parent PID=14727
Child (PID=14728) exiting
14727 pts/22   00:00:00 make_zombie
14728 pts/22   00:00:00 make_zombie <defunct>
After sending SIGKILL to zombie (PID=14728):
14727 pts/22   00:00:00 make_zombie
14728 pts/22   00:00:00 make_zombie <defunct>

说明SIGKILL对僵尸进程不起作用，僵尸进程在其父进程退出后也同样被回收。

3. SIGHLD信号

子进程的终止属于异步事件。即使父进程向子进程发送SIGKILL信号，子进程终止的确切时间还依赖与系统的调度：子进程下一次在何时使用CPU。

父进程使用wait()来防止僵尸子进程的累积，以及如下两种方法来避免这一问题：

• 父进程调用不带WNOHANG标志的wait()或waitpid()，此时如果尚无已经终止的子进程，那么调用将会阻塞。
• 父进程周期性地调用带有WNOHANG标志的waitpid()，执行针对已终止子进程的非阻塞式检查。

第一种方法会造成父进程阻塞；第二种造成CPU资源浪费，增加应用复杂度。

为了规避这些问题，可以采用这对SIGHLD信号的处理程序。

3.1 为SIGCHLD建立信号处理程序

无论一个子进程何时终止，系统都会向其父进程发送SIGHLD信号。

系统对SIGCHLD信号默认处理是将其忽略，如果通过安装处理程序来捕获它。

会面临如下问题：当调用信号处理程序时，会暂时将引发调用的信号阻塞起来，且不会带SIGCHLD之类的标准信号进行排队处理。当SIGHLD信号处理程序正在为一个终止的子程序运行时，如果相继有两个子进程终止，即使产生了两次SIGHLD信号，父进程也只能捕获到一个。如果父进程的SIGHLD信号处理程序每次只调用一次wait()，那么一些僵尸子进程可能会成为漏网之鱼。

下面的示例程序演示了如何写SIGCHLD处理函数，并且保证不会遗漏。而且说明了SIGCHLD信号不会排队，阻塞期间多次触发，在解除阻塞之后，只会执行一次。

#include <signal.h>
#include <sys/wait.h>
#include "print_wait_status.h"
#include "curr_time.h"
#include "tlpi_hdr.h"

static volatile int numLiveChildren = 0;
                /* Number of children started but not yet waited on */

static void
sigchldHandler(int sig)
{
    int status, savedErrno;
    pid_t childPid;

    /* UNSAFE: This handler uses non-async-signal-safe functions
       (printf(), printWaitStatus(), currTime(); see Section 21.1.2) */

    savedErrno = errno;         /* In case we modify 'errno' */

    printf("%s handler: Caught SIGCHLD
", currTime("%T"));

    /* Do nonblocking waits until no more dead children are found */

    while ((childPid = waitpid(-1, &status, WNOHANG)) > 0) {
        printf("%s handler: Reaped child %ld - ", currTime("%T"),
                (long) childPid);
        printWaitStatus(NULL, status);
        numLiveChildren--;
    }

    if (childPid == -1 && errno != ECHILD)
        errMsg("waitpid");

    sleep(5);           /* Artificially lengthen execution of handler */
    printf("%s handler: returning
", currTime("%T"));

    errno = savedErrno;
}

int
main(int argc, char *argv[])
{
    int j, sigCnt;
    sigset_t blockMask, emptyMask;
    struct sigaction sa;

    if (argc < 2 || strcmp(argv[1], "--help") == 0)
        usageErr("%s child-sleep-time...
", argv[0]);

    setbuf(stdout, NULL);       /* Disable buffering of stdout */

    sigCnt = 0;
    numLiveChildren = argc - 1;

    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sa.sa_handler = sigchldHandler;
    if (sigaction(SIGCHLD, &sa, NULL) == -1)-------------------------------------------------设置SIGCHLD信号处理函数。
        errExit("sigaction");

    /* Block SIGCHLD to prevent its delivery if a child terminates
       before the parent commences the sigsuspend() loop below */

    sigemptyset(&blockMask);
    sigaddset(&blockMask, SIGCHLD);
    if (sigprocmask(SIG_SETMASK, &blockMask, NULL) == -1)
        errExit("sigprocmask");

    /* Create one child process for each command-line argument */

    for (j = 1; j < argc; j++) {
        switch (fork()) {
        case -1:
            errExit("fork");

        case 0:         /* Child - sleeps and then exits */
            sleep(getInt(argv[j], GN_NONNEG, "child-sleep-time"));-----------------------------依次创建3个子进程，分别睡眠1、2、 4秒之后退出。
            printf("%s Child %d (PID=%ld) exiting
", currTime("%T"),
                    j, (long) getpid());
            _exit(EXIT_SUCCESS);

        default:        /* Parent - loops to create next child */
            break;
        }
    }

    /* Parent comes here: wait for SIGCHLD until all children are dead */

    sigemptyset(&emptyMask);
    while (numLiveChildren > 0) {
        if (sigsuspend(&emptyMask) == -1 && errno != EINTR)------------------------------------在此等待SIGCHLD信号。
            errExit("sigsuspend");
        sigCnt++;
    }

    printf("%s All %d children have terminated; SIGCHLD was caught "
            "%d times
", currTime("%T"), argc - 1, sigCnt);

    exit(EXIT_SUCCESS);
}

分别创建3个子进程，执行结果如下：

./multi_SIGCHLD 1 2 4
10:27:10 Child 1 (PID=14225) exiting------------------------------睡眠1秒的进程退出。
10:27:10 handler: Caught SIGCHLD----------------------------------父进程收到SIGHLD信号，并进入信号处理函数。
10:27:10 handler: Reaped child 14225 - child exited, status=0-----waitpid()回收子进程资源，然后开始睡眠5秒。此时SIGCHLD信号处理是被阻塞的。
10:27:11 Child 2 (PID=14226) exiting
10:27:13 Child 3 (PID=14227) exiting------------------------------2、4秒睡眠的子进程依次退出，但是由于此时SIGCHLD信号处于阻塞状态，所以不会立即被处理。
10:27:15 handler: returning---------------------------------------直到SIGCHLD处理函数退出，对SIGCHLD的阻塞解除。
10:27:15 handler: Caught SIGCHLD----------------------------------再次触发SIGCHLD信号处理函数，但是仅触发一次。
10:27:15 handler: Reaped child 14226 - child exited, status=0
10:27:15 handler: Reaped child 14227 - child exited, status=0
10:27:20 handler: returning---------------------------------------第二次SIGCHLD信号处理函数退出。
10:27:20 All 3 children have terminated; SIGCHLD was caught 2 times---整个流程结束。

3.2 向已停止的子进程发送SIGCHLD信号

当信号导致子进程停止时，父进程也就有可能收到SIGCHLD信号。调用sigaction()设置SIGCHLD信号处理程序时，如传入SA_NOCLDSTOP标志即可控制主义行为。如未使用，系统会在子进程停止时向父进程发送SIGCHLD信号。反之，就不会因子进程的停止而发出SIGCHLD信号。

3.3 忽略终止的子进程

将对SIGCHLD的处置显式置为SIG_IGN，系统从而会将其后终止的子进程立即删除，毋庸转为僵尸进程。将子进程的状态弃之不问，故而后续的wait()调用不会返回子进程的任何信息。

4. 小结