UNIX高级环境编程（9）进程控制（Process Control）- fork，vfork，僵尸进程，wait和waitpid

本章包含内容有：

• 创建新进程
• 程序执行（program execution）
• 进程终止（process termination）
• 进程的各种ID

?

1 进程标识符（Process Identifiers）

每个进程都有一个唯一的标识符，进程ID（process ID）。

进程的ID是可重用的，如果一个进程被终止，那么它的进程ID会被系统回收，但是会延迟使用，防止该进程ID标识的新进程被误认为是以前的进程。

三个特殊ID的进程：

• Process ID 0：调度者进程，内核进程。
• Process ID 1：init进程，内核引导程序最后启动，负责启动Unix系统。对应系统文件/sbin/init。
• Process ID 2：pagedaemon，负责虚拟内存的页管理。

获取进程各种ID的相关函数：

函数声明：

#include <unistd.h>

pid_t getpid(void); ? ? // Returns: process ID of calling process

pid_t getppid(void); ? ? ? ?// Returns: parent process ID of calling process

uid_t getuid(void); ? ? ? ?// Returns: real user ID of calling process

uid_t geteuid(void); ? ? ? // Returns: effective user ID of calling process

gid_t getgid(void); ? ? ? ?// Returns: real group ID of calling process

gid_t getegid(void); ? ? ? ?// Returns: effective group ID of calling process

这里的各种ID在前面第三篇中有说明，http://www.cnblogs.com/suzhou/p/4295535.html

?

2 fork函数

fork函数用于一个已存在的进程创建一个新的进程。

函数声明：

#include <unistd.h>

pid_t fork(void);

函数细节：

1. 创建的新进程叫做子进程，子进程是父进程的一个拷贝，拷贝数据段，堆和栈，而共享文本段。
2. 该函数调用一次，但是返回两次（父进程和子进程各返回一次，子进程返回0，父进程返回子进程的进程号）。这样设置的原因是：父进程可以有多个子进程，父进程没有方法获取子进程的进程号，而子进程只可能有一个父进程，并且可以通过getppid方法获取父进程的进程号。
3. 写时复制（copy-on-write）机制：子进程刚创建，在只读的情况下和父进程共享数据段、堆和栈。如果子进程或者父进程试着修改这些数据，内核会进程这些数据的拷贝。
4. 我们无法判断子进程和父进程的执行顺序，这取决于系统的调度顺序。

Example：

#include "apue.h"

?

int ? ? globvar = 6;? ? ? ? /* external variable in initialized data */

char? ? buf[] = "a write to stdout\n";

?

int

main(void)

{

? ? int ? ? var;? ? ? ? /* automatic variable on the stack */

? ? pid_t ? pid;

?

? ? var = 88;

? ? if (write(STDOUT_FILENO, buf, sizeof(buf)-1) != sizeof(buf)-1)

? ? ? ? err_sys("write error");

? ? printf("before fork\n");? ? /* we don‘t flush stdout */

?

? ? if ((pid = fork()) < 0) {

? ? ? ? err_sys("fork error");

? ? } else if (pid == 0) {? ? ? /* child */

? ? ? ? globvar++;? ? ? ? ? ? ? /* modify variables */

? ? ? ? var++;

? ? } else {

? ? ? ? sleep(2); ? ? ? ? ? ? ? /* parent */

? ? }

?

? ? printf("pid = %ld, glob = %d, var = %d\n", (long)getpid(), globvar,

? ? ? var);

? ? exit(0);

}

执行结果：

pid为12291的进程为子进程，对变量glob和var进行了加1。

当把输出重定向到一个文件时，我们发现结果和直接输出到终端中不太一样：

原因：?

• 函数write不使用缓存，所以在系统调用fork之前调用write，结果直接输出到标准输出上；
• 而标准输出如果连接到终端，则是行缓冲（line buffered），否则是全缓冲（full buffered）；
• 在第一个例子中，换行导致printf写入到标准输出中的数据flush到终端上（行缓冲，换新行，导致前面一行被打印）；
• 在第二个例子中，我们将标准输出重定向到文件，则使用全缓冲，printf的数据被缓存在buffer中没有被打印，在fork时，buffer同样被拷贝了一份，这样父子进程都有了一个标准IO缓存（standard IO buffer）；
• 程序中的第二个printf将新的内从append到buffer中已有数据的后面，一同打印出，就看到了第二个例子中打印的结果。

?

文件共享（File Sharing）

当调用fork函数时，父进程的所有打开的文件描述符都会复制一份到子进程中，包括文件偏移量（file offset）。

所以当父子进程同时写文件时，他们的操作都会更新同一个文件偏移量（file offset），加入子进程向文件中写入了一部分数据，同时更新了file offset，那么父进程进行写入操作时，会使用跟新以后的offset，从而避免了覆盖了子进程写入的数据。

父子进程共享文件如下图所示：

我们可以发现，父子进程拥有相同的文件描述符，又没有其他的同步方式，所以他们的输出可能会混起来（intermixed）。

fork之后，常见的处理父子进程拥有的文件描述符有两种方式：

• 父进程等待子进程完成。
• 父子进程各自工作，关闭不需要的文件描述符。

除了打开的文件描述，其他的子进程会继承自父进程的内容包括：

父子进程不同的地方包括：

• fork的返回值不同
• 进程ID不同
• 进程的父进程ID不同
• 子进程的tms_utime, tms_stime, itms_cutime和itms_cstime值被置为0
• 父进程的文件锁不会被子进程继承
• 子进程的pending signals被置空

?

3 vfork

vfork和fork有相同的返回值。

vfork和fork的不同点：

• 函数目的：vfork创建的子进程是为了让子进程执行一个新的程序
• 复制操作：不复制父进程的地址空间，而是直接运行在父进程的地址空间中，直到子进程调用exec或者exit
• 效率：所以vfork的执行效率比fork要高，因为它没有copy操作
• 不确定的结果：但是如果子进程修改了数据、调用函数或者没有调用exec和exit方法，则会造成不确定的结果
• 子进程先运行：vfork保证子进程先运行

?Example:

#include "apue.h"

?

int ? ? globvar = 6;? ? ? ? /* external variable in initialized data */

?

int

main(void)

{

? ? int ? ? var;? ? ? ? /* automatic variable on the stack */

? ? pid_t ? pid;

?

? ? var = 88;

? ? printf("before vfork\n"); ? /* we don‘t flush stdio */

? ? if ((pid = vfork()) < 0) {

? ? ? ? err_sys("vfork error");

? ? } else if (pid == 0) {? ? ? /* child */

? ? ? ? globvar++;? ? ? ? ? ? ? /* modify parent‘s variables */

? ? ? ? var++;

? ? ? ? _exit(0); ? ? ? ? ? ? ? /* child terminates */

? ? }

?

? ? /* parent continues here */

? ? printf("pid = %ld, glob = %d, var = %d\n", (long)getpid(), globvar,

? ? ? var);

?

? ? exit(0);

}

运行结果：

?

4 进程退出和僵尸进程

正常退出：三个函数exit，?

如果子进程不正常退出，则内核保证记录该进程的异常退出状态，该进程的父进程可以通过调用wait或者waitpid函数获取该子进程的异常退出状态。

如果父进程在子进程之前终止，则init进程成为该子进程的父进程。从而保证每个进程都有父进程。

如果子进程先终止（异常终止或者正常退出），内核会保存该子进程的部分信息，包括进程pid，进程终止时的状态和该进程占用的CPU时间，同时内核会清除该进程占用的内存，关闭所有已经打开的文件描述符。父进程可以通过检查该信息获取子进程的终止情况。

如果子进程先终止，而没有父进程调用waitpid获取该子进程的信息，那么这种进程被成为僵尸进程。使用ps命令可以看到僵尸进程的相关信息。

如果父进程为init进程，那么子进程异常终止并不会成为僵尸进程，因为init进程会对它的所有子进程调用wait函数获取子进程的终止状态。

?

5 wait和waitpid函数

子进程终止，内核会向父进程发送SIGCHLD信号。父进程默认的行为是忽略该信号，父进程也可以设置一个信号处理函数，当捕捉到该信号时，调用该处理函数，在后面的相关章节会介绍信号相关的概念。

本节介绍的wait和waitpid函数的作用是：

• 如果子进程在运行，则阻塞；
• 如果子进程终止，并且子进程的终止状态被父进程获取，则该函数立刻返回该终止状态；
• 如果该进程没有任何子进程，则返回错误。

需要注意的一点是，如果我们在接收到SIGCHLD信号后，调用wait函数，则该函数会立刻返回。在其他情况下调用wait函数，则会阻塞。

函数声明：

#include <sys/wait.h>

pid_t wait(int *statloc);

pid_t waitpid(pid_t pid, int *statloc, int options);?

// Both return: process ID if OK, 0,or -1 on error

两个函数之间的区别：

• wait函数会阻塞，一直到一个子进程终止；waitpid函数的参数options可以指定不阻塞；
• waitpid函数可以选择不阻塞，并且可以指定等待某一个子进程终止。

函数细节：

• 如果一个子进程终止并成为了僵尸进程，wait函数立刻返回该子进程的状态；
• 如果一个进程调用wait()函数并阻塞，并且有多个子进程，则当有一个子进程终止时，wait()函数返回；
• 参数statloc是一个整型指针，如果该参数不为null，则子进程的终止状态被保存在该参数指向的整型中；如果我们不关心进程的终止状态，statloc传入null就行；

返回值检查：

使用四个宏来检查wait和waitpid函数来获取子进程的终止状态（terminated status），如退出状态，信号值等信息。

四个宏的具体说明见下表所示：

pid的取值对waitpid函数行为的影响：

• pid == -1：行为和wait相同，等待任意一个子进程终止
• pid > 0：等待进程号为pid的进程终止
• pid ==0：等待进程组号和调用进程的进程组号相同的任意一个子进程终止
• pid < -1：等待进程组号等于pid的任意一个子进程终止

参数option的取值：

waitpid函数提供了三个wait没有的特性：

• waitpid可以让我们等待某一个特定的进程；
• waitpid提供了不阻塞版本的wait函数；
• option参数WCONTINUED和WUNTRACED为系统的任务控制（job control）提供了支持。

?

Example:

#include "apue.h"

#include <sys/wait.h>

?

int

main(void)

{

? ? pid_t ? pid;

?

? ? if ((pid = fork()) < 0) {

? ? ? ? err_sys("fork error");

? ? } else if (pid == 0) {? ? ? /* first child */

? ? ? ? if ((pid = fork()) < 0)

? ? ? ? ? ? err_sys("fork error");

? ? ? ? else if (pid > 0)

? ? ? ? {

? ? ? ? ? ? exit(0);? ? /* parent from second fork == first child */

? ? ? ? }

?

? ? ? ? /*

?? ? ? ? * We‘re the second child; our parent becomes init as soon

?? ? ? ? * as our real parent calls exit() in the statement above.

?? ? ? ? * Here‘s where we‘d continue executing, knowing that when

?? ? ? ? * we‘re done, init will reap our status.

? ? ? ? ?*/

? ? ? ? sleep(2);

? ? ? ? printf("second child, parent pid = %ld\n", (long)getppid());

? ? ? ? exit(0);

? ? }

?

? ? if (waitpid(pid, NULL, 0) != pid) ? /* wait for first child */

? ? ? ? err_sys("waitpid error");

?

? ? /*

?? ? * We‘re the parent (the original process); we continue executing,

?? ? * knowing that we‘re not the parent of the second child.

?? ? */

? ? exit(0);

}

执行结果：

结果分析：

在这里我们fork了两次，原因是，当我们想fork一个子进程出来，而我们不希望父进程阻塞在wait函数，并且不希望由于父进程没有调用wait函数先退出导致子进程成为僵尸进程，那么fork两次，并且退出第一个子进程，可以使得父进程及时退出，并且第二个子进程的父进程变成init进程。

?

小结

本篇主要介绍了fork、vfork、僵尸进程、wait和waitpid函数，这些在unix环境中都是很重要的概念和函数，并且在面试中也经常问到。

下一篇的内容包括：

• 解释器文件（interpreter files）
• 系统调用（system function）

?

参考资料：

《Advanced Programming in the UNIX Envinronment 3rd》

?