UNIX环境编程学习笔记（21）——进程管理之获取进程终止状态的 wait 和 waitpid 函数
lienhua34
2014-10-12
当一个进程正常或者异常终止时,内核就向其父进程发送 SIGCHLD信号。父进程可以选择忽略该信号,或者提供一个该信号发生时即被调用的函数(信号处理程序)。对于这种信号的系统默认动作是忽略它。
在文档“进程控制三部曲”中,我们讲的第三部曲是使用 wait 函数来获取终止子进程的终止状态。那么,有几个问题我们这里需要详细的学习一下。
1. 父进程一定能够获取到子进程的终止状态吗?如果子进程在父进程调用 wait 函数前就终止了,怎么办?
2. 如果父进程没有获取子进程的终止状态,那会发生什么?
3. 如果父进程有多个子进程,那么获取的是哪个子进程的终止状态呢?
对于第一个问题的回答是:内核为每个终止进程保存了一定量的信息,包括进程 ID、该进程的终止状态、以及该进程使用的 CPU 时间总量。所以,当终止进程的父进程调用 wait 或者 waitpid 函数,即可获取到这些信息。当父进程获取终止进程的终止信息之后,内核就可以释放终止进程所使用的所有存储区、关闭其所有打开的文件。
在 UNIX 术语中,一个已经终止、但是其父进程尚未对其进行善后处理(获取终止子进程的相关信息)的进程被称为僵尸进程(zombie)。如果编写一个长期运行的程序,调用 fork 产生子进程之后,需要调用 wait 来获取这些子进程的终止状态,否则这些子进程在终止之后将会变成僵尸进程。(后面会讲到用一个技巧以避开父进程调用 wait 获取所有子进程的终止状态。)
那么如果那些被 init 进程领养的进程在终止之后会不会也变成僵尸进程?答案是:不会。因为 init 进程无论何时只要有一个子进程终止,init 就会调用 wait 函数获取其终止状态。
那么关于上面的第三个问题,我们得通过详细学习 wait 和 waitpid 函数才能都做出回答了。
1 wait 函数
#include <sys/wait.h>
pid_t wait(int *statloc);
返回值:若成功则返回终止进程的ID,若出错则返回-1
参数 statloc 是一个整形指针。如果 statloc 不是一个空指针,则终止进程的终止状态将存储在该指针所指向的内存单元中。如果不关心终止状态,可以将 statloc 参数设置为空。
调用 wait 函数时,调用进程将会出现下面的情况:
• 如果其所有子进程都还在运行,则阻塞。
• 如果一个子进程已经终止,正等待父进程获取其终止状态,则获取该子进程的终止状态然后立即返回。
• 如果没有任何子进程,则立即出错返回。
wait 函数获取的终止状态是一个 int 型数值,那我们如何得到具体的终止信息呢?POSIX.1 规定终止状态用定义在 <sys/wait.h> 中的各个宏来参看。有四个互斥的宏可以用来得到进程的终止原因。这四个宏见表 1,
| 宏 | 说明 |
| WIFEXITED(status) | 若正常终止子进程返回的状态,则为真。此种情况,调用 WEXITSTATUS(status) 可以获取子进程调用 exit 函数的参数的低 8位。 |
| WIFSIGNALED(status) | 若为异常终止子进程返回的状态,则为真。此种情况,调用 WTERMSIG(status) 取得使子进程终止的信号编号。 |
| WIFSTOPPED(status) | 若为当前暂停子进程返回的状态,则为真。 |
| WIFCONTINUED(status) | 若在作业控制暂停后已经继续的子进程返回了状态,则为真。 |
下面我们来看一下打印终止进程状态说明的例子,
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/wait.h> extern void print_exit(int status); int main(void) { pid_t pid; int status; if ((pid = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid == 0) { exit(8); } if (wait(&status) != pid) { printf("wait error: %s\n", strerror(errno)); exit(-1); } print_exit(status); if ((pid = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid == 0) { abort(); } if (wait(&status) != pid) { printf("wait error: %s\n", strerror(errno)); exit(-1); } print_exit(status); exit(0); } void print_exit(int status) { if (WIFEXITED(status)) { printf("normal termination, exit status = %d\n", WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { printf("abnormal termination, signal number =%d\n", WTERMSIG(status)); } }
编译该程序,生成并运行 waitdemo 文件,
lienhua34:demo$ gcc -o waitdemo waitdemo.c lienhua34:demo$ ./waitdemo normal termination, exit status = 8 abnormal termination, signal number =6
下面我们再来看一个产生僵尸进程的示例,
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/wait.h> int main(void) { pid_t pid; if ((pid = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid == 0) { exit(0); } printf("fork child process:%d\n", pid); if ((pid = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid == 0) { exit(0); } printf("fork child process:%d\n", pid); if ((pid = wait(NULL)) < 0) { printf("wait error: %s\n", strerror(errno)); exit(-1); } printf("get child process(%d) termination status\n", pid); sleep(5); printf("parent process exit\n"); exit(0); }
我们在父进程最后 sleep(5) 让父进程睡眠 5 秒钟是避免父进程太早退出,我们观察不到僵尸进程。我们编译该程序文件,生成并执行文件
lienhua34:demo$ ps -A -ostat,pid | grep -e '[Zz]' Z 1725 lienhua34:demo$ gcc -o zombiedemo zombiedemo.c lienhua34:demo$ ./zombiedemo & [1] 2961 lienhua34:demo$ fork child process:2962 fork child process:2963 get child process(2963) termination status ps -A -ostat,pid | grep -e '[Zz]' Z 1725 Z 2962 lienhua34:demo$ parent process exit ps -A -ostat,pid | grep -e '[Zz]' Z 1725 [1]+ 完成 ./zombiedemo
ps 命令打印的进程中,Z 表示僵尸进程。从上面的运行结果,我们看到父进程(ID:2961)fork 了两个子进程(ID:2962 和 2963),然后调用了 wait 函数获取了子进程 2963 的终止状态,于是子进程 2962 便成为了僵尸进程。但是,当父进程也退出时,生成僵尸进程的子进程 2962 也被内核释放。
2 waitpid 函数
只要有一个子进程终止,wait 函数就会返回。那么如果父进程希望等待特定的子进程终止,该怎么办?UNIX 提供了提供这样功能的 waitpid 函数。
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *statloc, int options);
返回值:若成功则返回终止进程ID或0;若出错则返回-1
其中 statloc 参数跟 wait 函数一样,获取终止子进程的状态信息。waitpid 函数通过 pid 参数来控制父进程希望获取特定进程的终止状态信息,
• pid==-1:等待任一子进程,与 wait 函数等效。
• pid>0:等待其进程 ID 与 pid 相等的子进程。
• pid==0:等待其组 ID 等于调用进程组 ID 的任一子进程。(我们这里不学习进程组)
• pid<-1:等待其组 ID 等于 pid 绝对值的任一子进程。
waitpid 函数返回终止子进程的进程 ID。如果指定的进程或进程组不存在,或者参数 pid 指定的进程不是调用进程的子进程则都将出错。waitpid 函数跟 wait 函数的另一个不同之处在于,wait 函数可能会使调用进程阻塞,而 waitpid 函数可以通过第三个参数 options 来控制调用进程是否要阻塞。options 参数可以是 0,也可以是表 2 中各常量或运算的结果。
| 常量 | 说明 |
| WCONTINUED | 若实现支持作业控制,那么由 pid 指定的任一子进程在暂停后已经继续,但其状态尚未报告,则返回其状态。 |
| WNOHANG | 若由 pid 指定的子进程并不是立即可用的,则 waitpid 不阻塞,此时返回值为 0. |
| WUNTRACED | 若某实现支持作业控制,而由 pid 指定的任一子进程已处于暂停状态,并且其状态自暂停以来还未报告过,则返回其状态。 |
关于 options 用于作业控制 的两个 常量 WCONTINUED 和 WUNTRACED,我们这里不学习,我们只关心常量 WNOHANG。我们来看一个例子。
#include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/wait.h> int main(void) { pid_t pid1, pid2; pid_t waitpidRes; if ((pid1 = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid1 == 0) { sleep(3); printf("child process %d exit\n", getpid()); exit(0); } if ((pid2 = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid2 == 0) { printf("child process %d exit\n", getpid()); exit(0); } if ((waitpidRes = waitpid(pid1, NULL, 0)) == pid1) { printf("get terminated child process %d.\n", waitpidRes); } else if (waitpidRes < 0) { printf("waitpid error: %s\n", strerror(errno)); exit(-1); } else { printf("waitpid return 0\n"); } printf("parent process exit\n"); exit(0); }
在上面的程序中,我们在第一个子进程中 sleep(3) 让该子进程睡眠 3秒,以便在父进程调用 waitpid 函数时该子进程尚未结束。编译该程序,生成并执行 waitpiddemo 文件,
lienhua34:demo$ gcc -o waitpiddemo waitpiddemo.c lienhua34:demo$ ./waitpiddemo child process 2972 exit child process 2971 exit get terminated child process 2971. parent process exit
从上面的运行结果,我们可以看到父进程阻塞等待子进程 2971 终止。我们如果把上面程序的 waitpid 函数第三个参数 options 改为 WNOHANG,看一下其实际运行结果。
lienhua34:demo$ gcc -o waitpiddemo waitpiddemo.c lienhua34:demo$ ./waitpiddemo waitpid return 0 parent process exit child process 2982 exit lienhua34:demo$ child process 2981 exit
从上面的运行结果,我们可以看出父进程调用 waitpid 函数时,子进程2981 尚未终止,于是 waitpid 函数没有阻塞父进程,直接返回 0.
3 避免调用大量WAIT函数来防止僵尸进程的技巧
前面讲到僵尸进程时,我们提到要编写一个长期运行的程序,要避免出现大量的僵尸情况,就需要每次 fork 出一个子进程时都需要调用 wait 函数来等待子进程的结束以便处理该子进程的终止状态信息。但是,我们每次 fork 都要调用一个 wait 函数,实在是太麻烦了。
于是,我们就希望每次调用 fork 时不需要 wait 等待子进程终止,也不希望子进程处于僵死状态直到程序结束。这里提供一个实现此要求的技巧:调用 fork 两次。我们来看下面的例子:
#include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/wait.h> int main(void) { pid_t pid; if ((pid = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid == 0) { if ((pid = fork()) < 0) { printf("fork error: %s\n", strerror(errno)); exit(-1); } else if (pid > 0) { printf("first child process: %d, parent process: %d\n", getpid(), getppid()); exit(0); } sleep(2); printf("second child process: %d, parent process: %d\n", getpid(), getppid()); exit(0); } if (wait(NULL) < 0) { printf("wait error: %s\n", strerror(errno)); exit(-1); } printf("parent process %d exit\n", getpid()); exit(0); }
在上面程序中,在第一个子进程中 fork 处第二个子进程之后并终止第一个子进程。编译该程序,生成并执行文件 nozombiedemo,
lienhua34:demo$ gcc -o nozombiedemo nozombiedemo.c lienhua34:demo$ ./nozombiedemo first child process: 2471, parent process: 2470 parent process 2470 exit lienhua34:demo$ second child process: 2472, parent process: 1
从上面的运行结果,我们看到第一个子进程 2471 终止后,其子进程2472 的父进程 ID 变成了 1(即 init 进程)。前面我们提到过,父进程为 init进程的所有进程在终止时都会被 init 进程获取其终止状态,从而不会变成僵尸进程。于是,通过上面的 fork 两次的技巧,我们就可以实现创建一个新进程,不需要等待该新进程终止,也不担心该新进程会变成僵尸进程。
(done)