关于wait()与waitpid()的理解

介绍wait与waitpid之前先介绍进程同步：

有时候，父进程要求子进程的运算结果进行下一步的运算，或者子进程的功能是为父进程提供了下一步执行的先决条件（如：子进程建立文件，而父进程写入数据），此时父进程就必须在某一个位置停下来，等待子进程运行结束，而如果父进程不等待而直接执行下去的话，可以想见，会出现极大的混乱。这种情况称为进程之间的同步，更准确地说，这是进程同步的一种特例。进程同步就是要协调好2个以上的进程，使之以安排好地次序依次执行。解决进程同步问题有更通用的方法，我们将在以后介绍，但对于我们假设的这种情况，则完全可以用wait系统调用简单的予以解决。请看下面这段演示程序：

#include <sys/types.h>
#include <sys/wait.h>
main()
{
pid_t pc, pr;
int status;

pc=fork();

if(pc<0)
printf("Error occured on forking./n");
else if(pc==0){
/* 子进程的工作 */
exit(0);
}else{
/* 父进程的工作 */
pr=wait(&status);
/* 利用子进程的结果 */
}
}

这只是个演示例子，主要为了定性说明进程同步的使用情况和意义。当fork调用成功后，父子进程各做各的事情，但当父进程的工作告一段落，需要用到子进程的结果时，它就停下来调用wait，一直等到子进程运行结束，然后利用子进程的结果继续执行，这样就圆满地解决了我们提出的进程同步问题。wait()函数为进程同步做出了贡献。
wait() 与waitpid()函数格式如下：

#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid,int *statloc,int options);

这两个函数区别如下：

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

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

wait()函数结构

pid_t wait(int *statloc)

 函数返回值为结束子进程的进程号，当前进程中没有子进程则返回-1，参数为子进程结束状态指针，如果单纯想等待子进程的结束而不关心进程结束状态，参数写入NULL即可；若想获得子进程结束状态，将参数地址写入即可，例如定义 int statue存储子进程的结束状态，函数调用wait(&statue)即可;

一旦函数调用wait()，就会立即阻塞自己并自动判断当前进程中是否有某个子进程退出，wait()返回该子进程的状态，终止子进程的ID，所以它总能了解是哪一个子进程终止了。

程序演示：

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
int main(void)
{
pid_t pc,pr;  //一个用于进程判断 一个临时存储结束子进程的进程号
pc=fork();  //创建进程
if(pc<0) // 如果出错
printf("creat process faile!/n");  //打印错误信息
else if(pc==0){ /* 如果是子进程 */
printf(" child process  pid is %d/n",getpid()); //打印子进程进程号
sleep(10); // 睡眠10秒钟
}
else{ // 如果是父进程
pr=wait(NULL); // 在这里等待 不保存子进程状态信息
printf("I get a child process with pid of %d/n"),pr); //打印结束子进程的进程号
}
exit(0);
}

执行结果：

$ gcc wait.c -o wait
$ ./wait
child process pid is 3267
I get a child process with pid of 3267

执行时可以发现，当子进程打印完自身ID后，等待一段时间，父进程打印子进程进程号说明子进程已经退出，这里睡眠10秒不一定准确（linux软实时系统）。在子进程睡眠期间父进程一直等待并没有执行（阻塞状态）。

参数status：

如果参数status的值不是NULL，wait就会把子进程退出时的状态取出并存入其中，这是一个整数值（int），指出了子进程是正常退出还是被非正常结束的（一个进程也可以被其他进程用信号结束，以及正常结束时的返回值，或被哪一个信号结束的等信息。由于这些信息规定比较繁杂对人工判读造成一定困扰，人们就设计了一套专门的宏（macro）来完成这项工作，下面我们来学习一下其中最常用的两个：

1、WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值（请注意，虽然名字一样，这里的参数status并不同于wait唯一的参数---指向整数的指针status，而是那个指针所指向的整数）什么意思呢？wait()的参数是一个整形指针，而这个宏指向的是这个指针下的数 一个带* 一个不带*这样就清楚了吧。

2、WEXITSTATUS(status) 当WIFEXITED返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用exit(5)退出，WEXITSTATUS(status) 就会返回5；如果子进程调用exit(7)，WEXITSTATUS(status)就会返回7。请注意，如果进程不是正常退出的，也就是说， WIFEXITED返回0，这个值就毫无意义。

还有其他宏，例如： 

WIFSIGNALED(status)

WIFSTOPEED(status)

WIFCONTINUED(status)

使用较少这里不过多介绍。
这里通过实例演示一下：

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
main()
{
int status;
pid_t pc,pr;

pc=fork();
if(pc<0) /* 如果出错 */
printf("error ocurred!/n");
else if(pc==0){ /* 子进程 */
printf("This is child process with p
4000
id of %d./n",getpid());
exit(3); /* 子进程返回3 */
}
else{ // 父进程
pr=wait(&status);
if(WIFEXITED(status)){ //如果WIFEXITED返回非零值,证明是正常退出
printf("the child process %d exit normally./n",pr);
printf("the return code is %d./n",WEXITSTATUS(status));
}else /* 如果WIFEXITED返回零 */
printf("the child process %d exit abnormally./n",pr);
}
}

运行结果如下：

$ gcc wait2.c -o wait2
$ ./wait2
This is child process with pid of 1538.
the child process 1538 exit normally.
the return code is 3.

通过结果可以看出子进程是正常结束，但是一般不用这个宏来判断，exit(3)很难判断它的退出类型，是否属于正常退出，这就是使用宏的好处。

waitpid()函数结构如下：

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

pid：从参数的名字pid和类型pid_t中就可以看出，这里需要的是一个进程ID。但当pid取不同的值时，在这里有不同的意义。

         pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。

         pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。

         pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。

         pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。

第二个参数与wait相同，存储制定子进程终止的状态信息。为整形指针类型。

options：options提供了一些额外的选项来控制waitpid，目前在Linux中只支持WNOHANG和WUNTRACED两个选项，这是两个常数，可以用"|"运算符把它们连接起来使用。

WNOHANG：若pid指定进程并不是立即可用（终止状态），waitpid不阻塞，返回值为0.

WUNTRACED：若实现支持作业控制··· ···涉及到一些跟踪调试方面的知识，加之极少用到，这里就不多说了。

稍微琢磨一下就能看出，wait与waitpid有很大的关联性甚至wait就是封装了wairpid函数，没错！实际就是这样

察看<内核源码目录>/include/unistd.h文件349-352行就会发现以下程序段：

static inline pid_t wait(int * wait_stat)
{
return waitpid(-1,wait_stat,0);
}

返回值和错误

waitpid的返回值比wait稍微复杂一些，一共有3种情况：

          1、当正常返回的时候，waitpid返回收集到的子进程的进程ID；

          2、如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；

          3、如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid就会出错返回，这时errno被设置为ECHILD；

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
main()
{
pid_t pc, pr;

pc=fork();
if(pc<0) /* 如果fork出错 */
printf("Error occured on forking./n");
else if(pc==0){ /* 如果是子进程 */
sleep(10); /* 睡眠10秒 */
exit(0);
}
/* 如果是父进程 */
do{
pr=waitpid(pc, NULL, WNOHANG); /* 使用了WNOHANG参数，waitpid不会在这里等待 */
if(pr==0){ /* 如果没有收集到子进程 */
printf("No child exited/n");
sleep(1);
}
}while(pr==0); /* 没有收集到子进程，就回去继续尝试 */
if(pr==pc)
printf("successfully get child %d/n", pr);
else
printf("some error occured/n");
}

程序运行结果：

$ cc waitpid.c -o waitpid
$ ./waitpid
No child exited
No child exited
No child exited
No child exited
No child exited
No child exited
No child exited
No child exited
No child exited
No child exited
successfully get child 1526

父进程经过10次失败的尝试之后，终于收集到了退出的子进程。

因为这只是一个例子程序，不便写得太复杂，所以我们就让父进程和子进程分别睡眠了10秒钟和1秒钟，代表它们分别作了10秒钟和1秒钟的工作。父子进程都有工作要做，父进程利用工作的简短间歇察看子进程的是否退出，如退出就收集它。

在最后一个例子中把pr=waitpid(pc, NULL, WNOHANG); 

改为pr=waitpid(pc, NULL, 0);

或者pr=wait(NULL);

修改后的结果使得父进程将自己阻塞，直到有子进程退出为止