码迷，mamicode.com
首页 > 其他好文 > 详细

C函数篇(wait函数)

时间：2014-11-26 17:58:16      阅读：274      评论：0      收藏：0      [点我收藏+]

标签：style   io   ar   color   使用   sp   for   文件   数据   

  1. #include <sys/types.h>   
  2.   
  3. #include <sys/wait.h>  
  4.   
  5. pid_t wait(int *status)

进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经 退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就 会一直阻塞在这里，直到有一个出现为止。

参数status用来保存被收集进程退出时的一些状态，它是一个指向int类型的指针。但如果我们对这个子进程是如何死掉的毫不在意，只想把这个僵尸进程消灭掉，（事实上绝大多数情况下，我们都会这样想），我们就可以设定这个参数为NULL，就象下面这样

pid = wait(NULL); 

如果成功，wait会返回被收集的子进程的进程ID，如果调用进程没有子进程，调用就会失败，此时wait返回-1，同时errno被置为ECHILD。

下面就让我们用一个例子来实战应用一下wait调用：

  1. #include <sys/types.h>  
  2.   
  3. #include <sys/wait.h>  
  4.   
  5. #include <unistd.h>  
  6.   
  7. #include <stdlib.h>  
  8.   
  9. main()  
  10.   
  11. {  
  12.   
  13.      pid_t pc,pr;  
  14.   
  15.         pc=fork();  
  16.   
  17.   if(pc<0)                   
  18.   
  19.             printf("error ocurred!/n");  
  20.   
  21.  else if(pc==0){            
  22.   
  23.            printf("This is child process with pid of %d/n",getpid());  
  24.   
  25.           sleep(10);        
  26.   
  27.     }  
  28.   
  29.    else{                     
  30.   
  31.             pr=wait(NULL);    
  32.   
  33.             printf("I catched a child process with pid of %d/n"),pr);  
  34.   
  35.    }                 
  36.   
  37.     exit(0);  
  38.   
  39. } 

编译并运行:

  1. $ cc wait1.c -o wait1  
  2.   
  3. $ ./wait1  
  4.   
  5. This is child process with pid of 1508  
  6.   
  7. I catched a child process with pid of 1508 

可以明显注意到，在第2行结果打印出来前有10秒钟的等待时间，这就是我们设定的让子进程睡 眠的时间，只有子进程从睡眠中苏醒过来，它才能正常退出，也就才能被父进程捕捉到。其实这里我们不管设定子进程睡眠的时间有多长，父进程都会一直等待下 去，读者如果有兴趣的话，可以试着自己修改一下这个数值，看看会出现怎样的结果。数status：

1，WIFEXITED(status)这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值。

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

下面通过例子来实战一下我们刚刚学到的内容：

  1. #include <sys/types.h>  
  2.   
  3. #include <sys/wait.h>  
  4.   
  5. #include <unistd.h>  
  6.   
  7. main()  
  8.   
  9. {  
  10.   
  11.     int status;  
  12.   
  13.  pid_t pc,pr;  
  14.   
  15.         pc=fork();  
  16.   
  17.   if(pc<0)   
  18.   
  19.             printf("error ocurred!/n");  
  20.   
  21.  else if(pc==0){   
  22.   
  23.             printf("This is child process with pid of %d./n",getpid());  
  24.   
  25.          exit(3);          
  26.   
  27.     }  
  28.   
  29.    else{             
  30.   
  31.             pr=wait(&status);  
  32.   
  33.            if(WIFEXITED(status)){    
  34.   
  35.                     printf("the child process %d exit normally./n",pr);  
  36.   
  37.                  printf("the return code is %d./n",WEXITSTATUS(status));  
  38.   
  39.              }else                     
  40.   
  41.                     printf("the child process %d exit abnormally./n",pr);  
  42.   
  43.        }  
  44.   
  45. } 

编译并运行:

    1. $ cc wait2.c -o wait2  
    2.   
    3. $ ./wait2  
    4.   
    5. This is child process with pid of 1538.  
    6.   
    7. the child process 1538 exit normally.  
    8.   
    9. the return code is 3.

当然，处理进程退出状态的宏并不止这两个，但它们当中的绝大部分在平时的编程中很少用到，就也不在这里浪费篇幅介绍了，有兴趣的读者可以自己参阅Linuxman pages去了解它们的用法。

进程同步：

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

  1. #include <sys/types.h>  
  2.   
  3. #include <sys/wait.h>  
  4.   
  5. main()  
  6.   
  7. {  
  8.   
  9.    pid_t pc, pr;  
  10.   
  11.        int status;  
  12.   
  13.    
  14.   
  15.     pc=fork();  
  16.   
  17.     
  18.   
  19.     if(pc<0)  
  20.   
  21.              printf("Error occured on forking./n");  
  22.   
  23.       else if(pc==0){  
  24.   
  25.                
  26.   
  27.             exit(0);  
  28.   
  29.     }else{  
  30.   
  31.                 
  32.   
  33.             pr=wait(&status);  
  34.   
  35.              
  36.   
  37.     }  
  38.   
  39. } 

这段程序只是个例子，不能真正拿来执行，但它却说明了一些问题，首先，当fork调用成功 后，父子进程各做各的事情，但当父进程的工作告一段落，需要用到子进程的结果时，它就停下来调用wait，一直等到子进程运行结束，然后利用子进程的结果 继续执行，这样就圆满地解决了我们提出的进程同步问题。

waitpid系统调用在Linux函数库中的原型是：

  1. #include <sys/types.h>   
  2.   
  3. #include <sys/wait.h>  
  4.   
  5. pid_t waitpid(pid_t pid,int *status,int options)  
  • pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。
  • pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。
  • pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。
  • pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。

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

ret=waitpid(-1,NULL,WNOHANG | WUNTRACED); 

如果我们不想使用它们，也可以把options设为0，如：

ret=waitpid(-1,NULL,0); 

而WUNTRACED参数，由于涉及到一些跟踪调试方面的知识，加之极少用到，这里就不多费笔墨了，有兴趣的读者可以自行查阅相关材料。

看到这里，聪明的读者可能已经看出端倪了--wait不就是经过包装的waitpid吗？没错，察看<内核源码目录>/include/unistd.h文件349-352行就会发现以下程序段：

  1. static inline pid_t wait(int * wait_stat)  
  2.   
  3. {  
  4.   
  5.   return waitpid(-1,wait_stat,0);  
  6.   
  7. } 

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

当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid就会出错返回，这时errno被设置为ECHILD；

  1. #include <sys/types.h>  
  2.   
  3. #include <sys/wait.h>  
  4.   
  5. #include <unistd.h>  
  6.   
  7. main()  
  8.   
  9. {  
  10.   
  11.       pid_t pc, pr;  
  12.   
  13.                  
  14.   
  15.     pc=fork();  
  16.   
  17.   if(pc<0)           
  18.   
  19.             printf("Error occured on forking./n");  
  20.   
  21.       else if(pc==0){           
  22.   
  23.             sleep(10);        
  24.   
  25.             exit(0);  
  26.   
  27.     }  
  28.   
  29.      
  30.   
  31.     do{  
  32.   
  33.          pr=waitpid(pc, NULL, WNOHANG);    
  34.   
  35.             if(pr==0){                        
  36.   
  37.                     printf("No child exited/n");  
  38.   
  39.                         sleep(1);  
  40.   
  41.            }  
  42.   
  43.    }while(pr==0);                            
  44.   
  45.     if(pr==pc)  
  46.   
  47.           printf("successfully get child %d/n", pr);  
  48.   
  49.   else  
  50.   
  51.                 printf("some error occured/n");  
  52.   
  53. } 

编译并运行：

  1. $ cc waitpid.c -o waitpid  
  2.   
  3. $ ./waitpid  
  4.   
  5. No child exited  
  6.   
  7. No child exited  
  8.   
  9. No child exited  
  10.   
  11. No child exited  
  12.   
  13. No child exited  
  14.   
  15. No child exited  
  16.   
  17. No child exited  
  18.   
  19. No child exited  
  20.   
  21. No child exited  
  22.   
  23. No child exited  
  24.   
  25. successfully get child 1526 

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

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

 

C函数篇(wait函数)

标签：style   io   ar   color   使用   sp   for   文件   数据   

原文地址：http://www.cnblogs.com/sky-of-chuanqingchen/p/4123443.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！