精华内容
下载资源
问答
  • 父进程等待子进程退出并收集子进程退出状态 1.父进程为什么要等待子进程退出? 创建子进程目的:------干活 我们要知道干活结束没。 子进程退出状态不被收集,变成僵尸进程 等待:wait,waitpid函数: #include &...

    父进程等待(wait,waitpid)子进程退出并收集子进程退出状态

    1.父进程为什么要等待子进程退出?

    创建子进程目的:------干活
    我们要知道干活结束没。
    子进程退出状态不被收集,变成僵尸进程

    等待:wait,waitpid函数:

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

    Status参数:
    是一个整型数指针
    非空:子进程退出状态放在它所指向的地址中
    :不关心退出状态
    如果其所有子进程都还在运行,则wait阻塞
    如果一个子进程已终止,正等待父进程获取其终止状态,则wait取得该子进程的终止状态立即返回
    如果它没有任何子进程,则立即出错返回

    wait,waitpid的区别:

    区别:wait使调用者阻塞,waitpid有一个选项,可以使调用者不阻塞:options

    参数pid
    从参数的名字pid和类型pid_t中就可以看出,这里需要的是一个进程ID,但当pid取不同值的时候,在这里有不同的意义。
    1,pid>0时:只等待进程ID等于pid的子进程,不管其它有多少子进程运行结束退出了,只要指定的子进程还没有结束,waitpid就会一直等下去。
    2,pid=-1时:等待任何一个子进程退出,没有任何限制,此时waitpid和wait的作用一模一样。
    3.pid=0时:等待同一个进程组中的任何子进程,如果子进程已经进入了别的进程组,waitpid不会对它做出任何理睬。
    4,pid<-1时:等待一个指定进程中的任何子进程,这个进程组的ID等于pid的绝对值

    参数:options:
    在这里插入图片描述

    wait演示代码:

    #include <sys/types.h>
    #include <sys/wait.h> 
    #include <unistd.h> 
    #include <stdlib.h>
     #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    pid_t pid,pc; 
    int status; 
    printf("wait实例:\n"); 
    pid=fork(); 
    if(pid<0)//创建出错, 
    printf("error ocurred!\n"); 
    else if(pid == 0) //如果是子进程 
    { 
    printf("我是子进程的ID=%d\n",getpid());
     sleep(10); //睡眠10秒 
    exit(7); 
    } 
    else //父进程 
    { 
    pc=wait(&status); //等待子进程结束; 得到子进程的ID
    if(WIFEXITED(status)) //子程序正常结束返回非0值,异常返回0
    { 
    printf("我是父进程,我等待的子进程的id号=%d\n",pc); 
    printf("退出码是%d\n",WEXITSTATUS(status)); 
    } 
    else 
    { 
    printf("子进程退出异常!\n"); 
    } 
    } 
    exit(0);
    }
    

    代码实现:父进程等待子进程退出。
    在第3行结果打印出来前有10 秒钟的等待时间,这就是我们设定的让子进程睡眠的时间,只有子进程从睡眠中苏醒过来,它才能正常退出,也就才能被父进程捕捉到.

    运行结果:
    在这里插入图片描述
    waitpid代码演示:

    #include <sys/types.h>
    #include <sys/wait.h> 
    #include <unistd.h> 
    #include <stdlib.h>
     #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    pid_t pid,pc;
     pid=fork(); 
    int status; 
    if(pid<0) 
    { 
    printf("创建进程失败!\n"); 
    } 
    else if(pid==0) 
    { 
    printf("我是子进程,我的ID=%d\n",getpid());
     sleep(10); 
    exit(0); 
    } 
    else 
    { 
    do
    { 
    pc=waitpid(pid,&status,WNOHANG);//使用了WNOHANG参数,waitpid就不会等待,直接返回0. 
    // pc=waitpid(pid,&status,0); 
    if(pc==0) 
    { 
    printf("没有收集到子进程!\n"); 
    sleep(1); 
    } 
    }while(pc==0);//等不到,继续等, 
    if(pid==pc) 
    printf("等到了子进程\n");
     else printf("出错了\n");
     printf("我是父进程,我要等的进程id是%d\n",pc); 
    } 
    exit(0); 
    }

    运行结果:
    在这里插入图片描述
    从结果看出:

    先执行父进程,输出"没有收集到子进程",然后sleep(1),此时执行了子进程,输出"我是…31842",sleep(10);然后执行父进程,因为父进程不会等待子进程,所以不断的收集子进程,直到子进程sleep(10),结束后,才会收集到.

    展开全文
  • 原文地址:孤儿进程和僵尸进程进程没有执行wait退出了 作者:robert_ch http://blog.chinaunix.net/uid-31410005-id-5756407.html 一、定义:什么是孤儿进程和僵尸进程 僵尸进程:一个子进程在其父...

    原文地址:孤儿进程和僵尸进程 父进程没有执行wait就退出了 作者:robert_ch

    http://blog.chinaunix.net/uid-31410005-id-5756407.html


     孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作。

      僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或waitpid获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。


    一、定义:什么是孤儿进程和僵尸进程

    僵尸进程:一个子进程在其父进程还没有调用wait()或waitpid()的情况下退出。这个子进程就是僵尸进程。

    孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作。

    僵尸进程将会导致资源浪费,而孤儿则不会。

    子进程持续10秒钟的僵尸状态(EXIT_ZOMBIE)
    ------------------------------------------------------
    #include 
    #include 
    #include 
    #include

    main()
    {
        pid_t pid;
        pid = fork();
        if(pid < 0)
            printf("error occurred!/n");
        else if(pid == 0) {
            printf("Hi father! I'm a ZOMBIE/n");
            exit(0);      //(1)
        }
        else {
            sleep(10);
            wait(NULL);   //(2)
        }
    }

    (1) 向父进程发送SIGCHILD信号
    (2) 父进程处理SIGCHILD信号

    执行exit(0)时根据其父进程的状态决定自己的状态:
        如果父进程已经退出(没有wait),则该子进程将会成为孤儿进程过继给init进程
        如果其父进程还没有退出,也没有wait(),那么该进程将向父进程发送SIGCHILD信号,进入僵尸状态等待父进程为其收尸。如果父进程一直没有执行wait(),那么该子进程将会持续处于僵尸状态,如果父进程到死也没有执行wait则在死后会将zombie进程过继给init进程,由init进程来处理zombie进程,最终还是会死掉

     

     

    子进程将成为孤儿进程
    ------------------------------------------------------
    #include 
    #include 
    #include 
    #include

    main()
    {
        pid_t pid;
        pid = fork();
        if(pid < 0)
            printf("error occurred!/n");
        else if(pid == 0) {
            sleep(6);
            printf("I'm a orphan/n");
            exit(0);
        }
        else {
            sleep(1);
            printf("Children Bye!/n");
        }
    }

    # ./a.out
    Children Bye!
    # I'm a orphan
    (回车后将会进入#)
    #


    二、有什么害处:
    僵尸进程会占用系统资源,如果很多,则会严重影响服务器的性能
    孤儿进程不会占用系统资源,最终是由init进程托管,由init进程来释放它。
    处理流程:
    只要老爹不等wait(sys/wait.h)儿子,儿子都将成为孤魂野鬼zombie(zombie),unix中默认老爹总是想看儿子死后的状态(以便报仇)  
      if   老爹比儿子先再见  
      儿子将被init(id   =   1)收养,最后的结果是zombie儿子彻底再见,系统资源释放  
      else    
          {  
            儿子的zombie将一直存在,系统资源占用...  
            if   老爹dead    
                儿子将被init(id   =   1)收养,最后的结果是zombie儿子彻底再见,系统资源释放  
       
          else   类似的儿子zombie越来越多,系统就等死了!!!  
        } 

     

     

    signal(SIGCHLD, SIG_IGN); //忽略SIGCHLD信号,这常用于并发服务器的性能的一个技巧
                              //因为并发服务器常常fork很多子进程,子进程终结之后需要
                              //服务器进程去wait清理资源。如果将此信号的处理方式设为
                              //忽略,可让内核把僵尸子进程转交给init进程去处理,省去了
                              //大量僵尸进程占用系统资源。(Linux Only)

     

    三、如何防止僵尸进程
    首先明白如何产生僵尸进程:
    1、子进程结束后向父进程发出SIGCHLD信号,父进程默认忽略了它
    2、父进程没有调用wait()或waitpid()函数来等待子进程的结束
    第一种方法:  捕捉SIGCHLD信号,并在信号处理函数里面调用wait函数
    转贴Richard Steven的Unix Network Programming代码

    int
    main(int argc, char **argv)
    {
                    ...
            Signal(SIGCHLD, sig_chld);
                    for(;
                    }
                    ...
    }

    void
    sig_chld(int signo)
    {
            pid_t        pid;
            int        stat;

            while ( (pid = waitpid(-1, &stat, WNOHANG)) >; 0)
                    printf("child %d terminated/n", pid);
            return;
    }

     

     

    第二种方法:两次fork():转载
    在《Unix 环境高级编程》里关于这个在8.6节有非常清楚的说明。

    实例
    回忆一下8 . 5节中有关僵死进程的讨论。如果一个进程要f o r k一个子进程,但不要求它等待
    子进程终止,也不希望子进程处于僵死状态直到父进程终止,实现这一要求的诀窍是调用f o r k
    两次。程序8 - 5实现了这一点。
    在第二个子进程中调用s l e e p以保证在打印父进程I D时第一个子进程已终止。在f o r k之后,
    父、子进程都可继续执行——我们无法预知哪一个会先执行。如果不使第二个子进程睡眠,则
    在f o r k之后,它可能比其父进程先执行,于是它打印的父进程I D将是创建它的父进程,而不是
    i n i t进程(进程ID 1)。

    #include        
    #include        
    #include        "ourhdr.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 = %d/n", 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);
    }
      //avoid zombie process by forking twice

    展开全文
  • 可以使用wait函数传出参数status来保存进程的退出状态。常用宏函数分为日如下几...若上宏为真,此时可通过WEXITSTATUS(status)获取进程退出状态(exit时参数) 示例: if(WIFEXITED(status)){ printf("退出值为 %d\n",

    可以使用wait函数传出参数status来保存进程的退出状态


    常用宏函数分为日如下几组:
    1、 WIFEXITED(status) 若此值为非0 表明进程正常结束。
    若上宏为真,此时可通过WEXITSTATUS(status)获取进程退出状态(exit时参数)
    示例:

            if(WIFEXITED(status)){
                printf("退出值为 %d\n", WEXITSTATUS(status));
            }

    2、 WIFSIGNALED(status)为非0 表明进程异常终止。
    若上宏为真,此时可通过WTERMSIG(status)获取使得进程退出的信号编号
    用法示例:

        if(WIFSIGNALED(status)){
            printf("使得进程终止的信号编号: %d\n",WTERMSIG(status));   
        }

    3、 WIFSTOPPED(status)为非0 表明进程处于暂停状态
    若上宏为真,此时可通过WSTOPSIG(status)获取使得进程暂停的信号编号
    4、 WIFCONTINUED(status) 非0表示暂停后已经继续运行。


    WIFEXITED和WIFSIGNALED用法完整程序:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    
    int main(void)
    {
        pid_t pid, wpid;
        int status;
    
        pid = fork();
        if(pid == 0){               //子进程
            printf("child --- my parent is %d\n", getppid());
            sleep(30);              //子进程睡眠30秒
            printf("child is die\n");
         }else if(pid>0){           //父进程
            wpid = wait(&status);   //等待回收子进程
            if(wpid == -1){
                perror("wait error:");
                exit(1);
            }
            //正常退出判断
            if(WIFEXITED(status)){
                printf("child exit with %d\n", WEXITSTATUS(status));
            }
    
            //因为某种信号中断获取状态
            if(WIFSIGNALED(status)){
                printf("child killed by %d\n", WTERMSIG(status));
            }
    
            while(1)
            {
                printf("parent pid = %d, sonpid = %d\n", getpid(), pid);
                sleep(1);
            }
            } else {
                perror("for error");
                exit(1);
            }
    
        return 0;
    }

    测试程序
    编译程序:

    yu@ubuntu:~/cplusplus/wait进程控制$ gcc getstatus.c -o getstatus.out

    1、首先测试WIFEXITED正常退出情况,执行:

    yu@ubuntu:~/cplusplus/wait进程控制$ ./getstatus.out 
    child --- my parent is 6408
    child is die
    child exit with 0
    parent pid = 6408, sonpid = 6409
    parent pid = 6408, sonpid = 6409
    parent pid = 6408, sonpid = 6409
    parent pid = 6408, sonpid = 6409
    ....

    2、测试WIFSIGNALED信号终止,执行(sleep(300)便于测试):

    yu@ubuntu:~/cplusplus/wait进程控制$ ./getstatus.out 
    child --- my parent is 6418

    此时另开一终端,查看进程,kill命令终止子进程:

    yu@ubuntu:~/cplusplus/Process$ ps aux | grep getstatus.out
    yu         6437  0.0  0.0   4224   784 pts/18   S+   21:58   0:00 ./getstatus.out
    yu         6438  0.0  0.0   4356    84 pts/18   S+   21:58   0:00 ./getstatus.out
    yu         6442  0.0  0.0  21292   976 pts/4    S+   21:58   0:00 grep --color=auto getstatus.out
    
    yu@ubuntu:~/cplusplus/Process$ kill 6438

    此时子进程异常终止,getstatus.out 程序输出信息:

    yu@ubuntu:~/cplusplus/wait进程控制$ ./getstatus.out 
    child --- my parent is 6437
    child killed by 15
    parent pid = 6437, sonpid = 6438
    parent pid = 6437, sonpid = 6438
    parent pid = 6437, sonpid = 6438
    parent pid = 6437, sonpid = 6438
    ...

    如上所知,使得进程终止的信号编号为15,通过 kill –l可知15号信号为SIGTERM:

    yu@ubuntu:~/cplusplus/wait进程控制$ kill -l
     1) SIGHUP   2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP
     6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1
    11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
    16) SIGSTKFLT   17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
    21) SIGTTIN 22) SIGTTOU 23) SIGURG  24) SIGXCPU 25) SIGXFSZ
    26) SIGVTALRM   27) SIGPROF 28) SIGWINCH    29) SIGIO   30) SIGPWR
    31) SIGSYS  34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
    38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
    43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
    48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
    53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
    58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
    63) SIGRTMAX-1  64) SIGRTMAX    
    展开全文
  • #include <sys/types.h> /* 提供类型pid_t的定义 */ #include <sys/wait.h> pid_t wait(int *status) <br />进程一旦调用了wait,就立即阻塞自己,由wait自动分析是否当前进程的某个子进程已经退出,...
    #include <sys/types.h> /* 提供类型pid_t的定义 */
    #include <sys/wait.h>
    pid_t wait(int *status)

    进程一旦调用了wait,就立即阻塞自己,由wait自动分析是否当前进程的某个子进程已经退出,如果让它找到了这样一个已经变成僵尸的子进程,wait就会收集这个子进程的信息,并把它彻底销毁后返回;如果没有找到这样一个子进程,wait就会一直阻塞在这里,直到有一个出现为止。
    参数status用来保存被收集进程退出时的一些状态,它是一个指向int类型的指针。但如果我们对这个子进程是如何死掉的毫不在意,只想把这个僵尸进程消灭掉,(事实上绝大多数情况下,我们都会这样想),我们就可以设定这个参数为NULL,就象下面这样:

    		pid = wait(NULL);

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


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

    /* wait1.c */
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    #include <stdlib.h>
    main()
    {
    pid_t pc,pr;
    pc=fork();
    if(pc<0) /* 如果出错 */
    printf("error ocurred!/n");
    else if(pc==0){ /* 如果是子进程 */
    printf("This is child process with pid of %d/n",getpid());
    sleep(10); /* 睡眠10秒钟 */
    }
    else{ /* 如果是父进程 */
    pr=wait(NULL); /* 在这里等待 */
    printf("I catched a child process with pid of %d/n"),pr);
    }
    exit(0);
    }


    编译并运行:

    $ cc wait1.c -o wait1
    $ ./wait1
    This is child process with pid of 1508
    I catched a child process with pid of 1508

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

    参数status:

    如果参数status的值不是NULL,wait就会把子进程退出时的状态取出并存入其中,这是一个整数值(int),指出了子进程是正常退出还是被非正常结束的(一个进程也可以被其他进程用信号结束,我们将在以后的文章中介绍),以及正常结束时的返回值,或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中,所以用常规的方法读取会非常麻烦,人们就设计了一套专门的宏(macro)来完成这项工作,下面我们来学习一下其中最常用的两个:

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

    (请注意,虽然名字一样,这里的参数status并不同于wait唯一的参数--指向整数的指针status,而是那个指针所指向的整数,切记不要搞混了。)

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

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

    /* wait2.c */
    #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 pid 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);
    }
    }

    编译并运行:

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

    父进程准确捕捉到了子进程的返回值3,并把它打印了出来。

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

    进程同步:

    有时候,父进程要求子进程的运算结果进行下一步的运算,或者子进程的功能是为父进程提供了下一步执行的先决条件(如:子进程建立文件,而父进程写入数据),此时父进程就必须在某一个位置停下来,等待子进程运行结束,而如果父进程不等待而直接执行下去的话,可以想见,会出现极大的混乱。这种情况称为进程之间的同步,更准确地说,这是进程同步的一种特例。进程同步就是要协调好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,一直等到子进程运行结束,然后利用子进程的结果继续执行,这样就圆满地解决了我们提出的进程同步问题。






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

    #include <sys/types.h> /* 提供类型pid_t的定义 */
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid,int *status,int options)

    从本质上讲,系统调用waitpid和wait的作用是完全相同的,但waitpid多出了两个可由用户控制的参数pid和options,从而为我们编程提供了另一种更灵活的方式。下面我们就来详细介绍一下这两个参数:

    pid

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

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

    options

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

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

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

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

    如果使用了WNOHANG参数调用waitpid,即使没有子进程退出,它也会立即返回,不会像wait那样永远等下去。

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

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

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


    1.9.2 返回值和错误

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

    1. 当正常返回的时候,waitpid返回收集到的子进程的进程ID;
    2. 如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0;
    3. 如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在;

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

    /* waitpid.c */
    #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秒钟的工作。父子进程都有工作要做,父进程利用工作的简短间歇察看子进程的是否退出,如退出就收集它。

    展开全文
  • 当子进程退出,向父进程发生SIGCHLD时,在父进程的信号处理函数中 wait(NULL), 和 wait(-1,NULL,WHOHANG)的区别 阻塞方式 和 不阻塞到底对子进程的回收有什么影响??
  • 因此一般情况下要求子进程先于父进程退出(在父进程中调用wait函数,或者使用信号),这样就可以防止孤儿进程的产生。 waitpid函数 头文件:同wait函数 函数原型:pid_t waitpid(pid_t pid,int * status,...
  • 在上一篇博客中提到进程等待时,用到...在这两个函数中都有这样一个整型参数status,这个参数的作用就是:获取子进程退出状态; 那么如何利用这个参数来得出子进程的退出状态? 首先,先来了解一下这个参数的结构 ...
  • 前言父进程异常退出时,如果子进程退出,或者对于父进程退出不知情,将会导致子进程变成孤儿进程,更严重的情况是,如果父进程需要使用端口,而父进程异常退出,父进程再次启动时,会发现其子进程占用其端口。...
  • 进程退出函数02. 进程退出讨论03. 回收进程资源04. 附录 01. 进程退出函数 #include <stdlib.h> void exit(int status); 功能: 结束调用此函数的进程。 参数: status:返回给父进程的参数(低 8 位有效...
  • 一、wait回收子进程 一个进程在终止时会关闭所有文件描述符,释放在用户空间分配的内存,==但它的PCB还保留着,内核在其中保存了一些信息:==如果是正常终止则保存着退出状态;如果是异常终止则保存着导致改进程终止...
  • linux系统编程之进程(六):父进程查询子进程的退出,wait,waitpid   本节目标: 僵进程 ...子进程退出时,内核将子进程置为僵尸状态,这个进程称为僵尸进程,它只保留最小的一些内核数据结构,以...
  • 16进程学习之wait回收子进程并且获取正常退出的返回值和异常退出的信号值 1 概述 一个进程在终止时会关闭所有文件描述符,释放在用户空间分配的内存,但它的PCB还保留着,内核在其中保存了一些信息:如果是正常终止...
  • Linux进程控制--进程退出和等待

    千次阅读 2018-11-03 21:44:45
    Linux进程退出 1. 进程退出的场景 代码运行完毕正常退出,结果正确 代码运行完毕正常退出,结果不正确 异常退出 2 .进程常见退出方式 正常退出 从main() 函数中返回return退出 调用exit()函数退出 调用_exit()...
  • 为什么要等待子进程退出 父进程等待子进程退出并收集子进程退出状态 子进程退出状态不被收集,会变成僵尸进程 举个例子 #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include...
  • 进程退出函数exit()

    千次阅读 2017-04-24 10:03:23
    在多进程编程中(这里讲Linux平台),某个...为避免子进程成为僵尸进程,父进程是调用wait()或者waitpid()来获取子进程退出状态。父进程wait()(或者waitpid())结合子进程的exit()可以得到: 1) 子进程是否正常退出
  • 一、进程退出 当一个进程终止了,我们需要知道进程退出时的状态,我们需要通过进程结束时的退出码来识别。 进程正常结束时: 1.从main()函数返回 2.调用exit()函数 3.调用_exit()//系统调用 我们可以用(echo ...
  • Linux进程退出

    千次阅读 2016-08-23 15:43:28
    #include int main(void) { return -1; } ...编译好,然后运行,然后在shell里面查看进程退出...还得从进程的状态码开始讲起,我们知道,当一个进程退出的时候,父进程一般都会进行收尾工作,就是调用wait或者w
  • 1、进程退出atexit函数称为终止处理程序注册程序 在Linux下 man atexit 就可以查看atexit的用法。...注册函数fun1(),用atexit调用,调用了以后先不执行fun1,而是先记住,进程退出后,再运行fun1的这个函数。
  • 原书中应该是个错误,没有把等待放入到父进程代码区,搞得子进程也在执行wait 修改之二,将子进程产生一个睡眠时间,这样可以看到输出,睡眠一个固定时间sleep(5);或者睡眠一个递增时间、用来产生仅仅一个进程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,525
精华内容 45,010
关键字:

wait进程退出