精华内容
下载资源
问答
  • C语言wait()函数:结束(中断)进程函数(常用) 头文件: #include <sys> #include 定义函数: pid_t wait (int * status); 函数说明:wait()会暂时停止目前进程的执行, 直到有信号来到或子进程结束. 如果在调用...
  • 进程一旦调用了wait,就立即阻塞自己,由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。

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

    /* 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);
    

    }

    编译并运行:

    $ gcc 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);
    
        }
    

    }

    编译并运行:

    $ 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.

    父进程准确捕捉到了子进程的返回值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取不同的值时,在这里有不同的意义。
    pid>0时,只等待进程ID等于pid的子进程,不管其它已经有多少子进程运行结束退出了,只要指定的子进程还没有结束,waitpid就会一直等下去。
    pid=-1时,等待任何一个子进程退出,没有任何限制,此时waitpid和wait的作用一模一样。
    pid=0时,等待同一个进程组中的任何子进程,如果子进程已经加入了别的进程组,waitpid不会对它做任何理睬。
    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);
    }
    返回值和错误
    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秒钟的工作。父子进程都有工作要做,父进程利用工作的简短间歇察看子进程的是否退出,如退出就收集它。

    提示:可以尝试在最后一个例子中把pr=waitpid(pc, NULL, WNOHANG); 改为pr=waitpid(pc, NULL, 0);或者pr=wait(NULL);看看运行结果有何变化?(修改后的结果使得父进程将自己阻塞,直到有子进程退出为止!)
    ————————————————
    版权声明:本文为CSDN博主「kevinhg」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/kevinhg/article/details/7001719

    展开全文
  • wait和waitpid函数总结

    千次阅读 2016-07-27 21:56:23
    wait和waitpid两个函数的功能: 1.防止产生僵尸进程 2.跟据需求,先让父进程挂起等待子进程结束后,再运行,实现进程的同步。 僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或...

    wait和waitpid两个函数的功能:

    1.防止产生僵尸进程             

    2.根据需求,先让父进程挂起等待子进程结束后,再运行,实现进程的同步。


    僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或waitpid获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
    如果进程不调用wait / waitpid的话, 那么保留的那段信息就不会释放,其进程号就会一直被占用,但是系统所能使用的进程号是有限的,如果大量的产生僵死进程,将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸进程的危害,应当避免。


    wait函数:

    函数原型:

    #include <sys/types.h> 
    #include <sys/wait.h>

    pid_t wait(int *status)


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

    参数status用来保存被收集进程退出时的一些状态,它是一个指向int类型的指针。

    参数status:

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

    1.WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的,如果是,它会返回一个非零值。
    2. WEXITSTATUS(status) 当WIFEXITED返回非零值时,我们可以用这个宏来提取子进程的返回值,如果子进程调用exit(5)退出,WEXITSTATUS(status) 就会返回5;如果子进程调用exit(7),WEXITSTATUS(status)就会返回7。
    但如果我们对这个子进程是如何死掉的毫不在意,只想把这个僵尸进程消灭掉,(事实上绝大多数情况下,我们都会这样想),我们就可以设定这个参数为NULL,就象下面这样:
     pid = wait(NULL);

    3.WIFSIGNALED(status)若为异常结束子进程返回的状态,则为真;对于这种情况可执行WTERMSIG(status),取使子进程结束的信号编号。

    4.WTERMSIG(status) 取得子进程因信号而中止的信号代码,一般会先用 WIFSIGNALED 来判断后才使用此宏。

    5.WIFSTOPPED(status) 若为当前暂停子进程返回的状态,则为真;对于这种情况可执行WSTOPSIG(status),取使子进程暂停的信号编号。

    6.WSTOPSIG(status) 取得引发子进程暂停的信号代码,一般会先用 WIFSTOPPED 来判断后才使用此宏。



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



    waitpid函数:

    函数原型:

    #include <sys/types.h> 
    #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取不同的值时,在这里有不同的意义。

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


    参数options:

    ptions提供了一些额外的选项来控制waitpid,目前在Linux中只支持WNOHANG和WUNTRACED两个选项,这是两个常数,可以用"|"运算符把它们连接起来使用,比如:
    ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);
     
    如果我们不想使用它们,也可以把options设为0,如:
    ret=waitpid(-1,NULL,0);
     
    如果使用了WNOHANG参数调用waitpid,即使没有子进程退出,它也会立即返回,不会像wait那样永远等下去。

    WUNTRACED 若子进程进入暂停状态,则马上返回,但子进程的结束状态不予以理会。
    WCONTINUED //如果停止了的进程由于SIGCONT信号的到来而继续运行,调用将返回。


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

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





    展开全文
  • 进程等待的方法有wait方法和waitpid方法。 这里了解一下函数的使用,头文件包含以及函数原型,以及返回值等等。 wait函数 #include<sys/types.h> #include<sys/wait.h> pid_t wait(int *status); //该...

    一个进程在终止时会关闭所有文件描述符,释放在用户空间分配的内存,但它的PCB还保留着,内核在其中保存了一些信息:如果是正常终止则保存着退出状态,如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用wait或waitpid函数获取这些信息,然后彻底清除掉这个进程

    • 函数功能:父进程调用wait函数可以回收子进程终止信息。该函数有三个功能:
      1. 阻塞等待子进程退出
      2. 回收子进程残留资源
      3. 获取子进程结束状态(退出原因)。

    wait一旦被调用,就会一直阻塞在这里,直到有一个子进程退出出现为止

    进程等待的方法有wait方法和waitpid方法。
    这里了解一下函数的使用,头文件包含以及函数原型,以及返回值等等。
    wait函数

    #include<sys/types.h>
    #include<sys/wait.h>
    pid_t wait(int *status);
    //该函数的参数为输出型参数,该参数可以获得被等待进程的退出状态信息,并把该信息带出
    //返回值:失败返回-1,成功就返回被等待进程的pid.
    

    这里大概解释一下输出型参数,函数的输入和输出是靠函数参数的 。如果这个参数是用来做输入的,就叫输入型参数 ,如果这个参数是用来做输的,就叫输出型参数 。
    waitpid函数

    #include<sys/types.h>
    #include<sys/wait.h>
    pid_t waiitpid(pid_t pid,int *status,int options);
    //该函数的参数:
    //第一个参数pid:
    //pid=-1,等待任意一个子进程,此时的作用相当于wait函数。
    // pid>0,等待一个进程ID是pid的子进程。
    //第二个参数status:
    //WIFEXITED(status)(查看子进程是否正常退出),若为正常终止子进程退出的状态,则为真,否则为假
    //WEIXTSTATUS(status)(获取进程的退出吗),在该进程正常终止(WIFEXITED(status)不为0)的情况下才有意义,提取子进程退出码。
    //第三个参数options:
    //WNOHANG:若pid对应的子进程没有结束,则返回0,若该子进程结束,则返回子进程的ID.
    //返回值:-1 0 大于0
    若waitpid等到了正常终止的子进程,则返回该子进程的ID(即为大于0 的情况);
    若设置了WNOHANG的值,而等不到正常退出的子进程,即返回0;
    若调用waitpid函数出错,则返回-1;
                             
    

    如果,在调用wait或waitpid的函数时,子进程已经退出了,函数会立即退出,并同时释放资源,获取该子进程的退出信息。若子进程存在且依旧在运行(未退出),则进程有可能阻塞。若不存在该子进程,则函数出错返回。

    若有错误,欢迎指正 😃

    展开全文
  • linux c之wait和waitpid函数的用法总结

    万次阅读 多人点赞 2017-01-13 17:56:56
    1、wait和waitpid函数的介绍 1) wait()函数用于使父进程(也就是调用wait()的进程)阻塞,直到一个子进程结束或者该进程接收到了一个指定的信号为止。如果该父进程没有子进程或者它的子进程已经结束,则wait()函数...

    1、wait和waitpid函数的介绍

     

           1)  wait()函数用于使父进程(也就是调用wait()的进程)阻塞,直到一个子进程结束或者该进程接收到了一个指定的信号为止。如果该父进程没有子进程或者它的子进程已经结束,则wait()函数就会立即返回。

            2) waitpid()的作用和wait()一样,但它并不一定要等待第一个终止的子进程(它可以指定需要等待终止的子进程),它还有若干选项,如可提供一个非阻塞版本的 wait()功能,也能支持作业控制。实际上,wait()函数只是 waitpid()函数的一个特例,在Linux 内部实现 wait()函数时直接调用的就是waitpid()函数。

     

    2、僵尸进程的介绍


           系统调用exit后,该进程并非马上消失,而是留下一个叫僵尸进程的数据结构,僵尸进程是非常特使的一种,它放弃了几乎所有的内存空间,没有任何可执行代码,也不能别调度,仅仅在进程列表保留位置,而且不占用任何内存空

    展开全文
  • 【Linux】wait和waitpid区别

    千次阅读 2018-08-30 16:39:59
    先来看一下这两个函数的函数原型 这两个函数的功能都是回收已经退出的子进程的资源,获取子进程的退出信息,...再来看waitpid函数: 函数参数: pid: pid=-1,等待任意一个子进程,和wait等效 pid&gt;0:...
  • wait和waitpid区别

    千次阅读 2016-01-23 00:10:12
    首先奉上这两个函数 ... wait和waitpid都是用来处理终止进程的,这两个函数都返回两个值:已终止的进程ID号,以及通过statloc指针返回的子进程的状态(一个整数)。如果调用wait()的进程没有终止的进程而还有一个
  • Liunx — 进程等待 (wait和waitpid函数)

    千次阅读 2017-06-20 00:04:08
    那么当父进程调用了wait和waitpid函数后,会发生什么情况呢? 如果其所有子进程都还在运行,则阻塞. 如果一个子进程已终止,正等待父进程获取其终止状态,则取得该子进程的终止态立即返回. 如果它没有任何子进程,则...
  • 一个进程在终止时会关闭所有的文件描述符,释放用户空间分配的... 在父进程中可以调用wait和waitpid函数来获取进程信息,然后彻底清除这个进程。  (1)wait函数  函数原型及头文件: 函数功能:1)阻塞等...
  • 详解wait和waitpid函数

    万次阅读 多人点赞 2011-11-22 20:38:34
    进程一旦调用了wait,就立即阻塞自己,由wait自动分析是否当前进程的某个子进程已经退出,如果让它找到了这样一个已经变成僵尸的子进程,wait就会收集这个子进程的信息,并把它彻底销毁后返回;如果没有找到这样一...
  • 函数说明  wait()函数用于使父进程(也就是调用... waitpid()的作用和wait()一样,但它并不一定要等待第一个终止的子进程(它可以指定需要等待终止的子进程),它还有若干选项,如可提供一个非阻塞版本的 wait()功
  • #include /* 提供类型pid_t的定义 */#include pid_t wait(int *status)进程一旦调用了wait,就立即阻塞自己,由wait自动分析是否当前进程的某个子进程已经退出,如果让它找到了这样一个已经变成僵尸的子进程,wait就...
  • wait和waitpid函数详解

    2014-01-06 09:59:04
    wait和waitpid详解 wait函数原型是: #include #include pid_t wait(int *status)  进程一旦调用了wait,就立即阻塞自己,由wait自动分析是 否当前进程的某个子进程已经...
  • 僵尸进程以及wait和waitpid函数

    千次阅读 2016-11-21 14:18:32
    当一个 进程完成它的工作终止之后,它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态。 孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进
  • wait函数和waitpid函数

    2019-10-03 19:55:23
       当一个进程结束时,会关闭所有的文件描述符,...父进程通过调用wait()或者waitpid()函数,来获取这些信息,之后彻底清除改进程。     父进程调用wait函数可以回收子进程终止信息,该函数有三...
  • fork函数和wait/waitpid函数

    千次阅读 2016-12-04 13:10:47
    使用fork函数得到的子进程从父进程的继承了整个进程的地址空间,包括:进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设置、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端等。...
  • wait waitpid 函数

    2017-08-30 23:47:50
    当一个进程正常终止或异常终止...可以使用 wait waitpid 函数来获取子进程的终止状态。 [code="C"] #include pid_t wait(int *statloc); pid_t waitpid(pid_t pid, int *statloc, int options); ...
  • 4. waitpid函数  pid_t waitpid(pid_t pid, int *status, int options);  功能:和wait一样,但是这个函数清除指定的pid,可以不阻塞父进程 返回值:成功返回清除掉的进程pid,失败返回-1 (无子进程) 。...
  • 3、(wait 和waitpid区别wait 使调用者阻塞,waitpid有一个选项,可以使调用者不阻塞。 4、孤儿进程 1、子进程退出状态不被父进程收集,变成僵死进程(僵尸进程) #include <unistd.h> #include <...
  • 一个进程在终止时会关闭...这个进程的父进程可以调用waitwaitpid获取这些信息,然后彻底清除掉这个进程。我们知道一个进程的退出状态可以在Shell中用特殊变量$?查看,因为Shell是它的父进程,当它终止时Shell调用wa
  • wait和waitpid函数

    2016-07-09 17:30:12
    当一个进程正常或异常终止时,内核就向其父进程发送一个SIGCHLD信号。...调用waitwaitpid的进程可能会发生的情况:  1.如果其所有子进程都还在运行,则阻塞  2.如果一个子进程已终止,正等待父进程获
  • 当一个进程正常或异常终止时,内核就向其父进程发送SIGCHLD信号。因为子进程终止是个异步事件(这可以在父进程运行的任何时候... 调用waitwaitpid的进程可能会发生的情况: 如果其所有子进程都还在运行,则阻塞。...
  • waitwaitpid函数

    2020-12-04 13:37:21
    函数的定义 #include <sys/wait.h> pid_t wait(int *wstatus); pid_t waitpid(pid_t pid, int *wstatus, int options); wait函数 pid_t wait(int *wstatus);...waitpid函数 pid_t waitpid(p
  • Linux signal, wait, waitpid 函数

    千次阅读 2016-10-15 21:29:00
    一、signal 函数1、定义#include signal(参数1,参数2); /* * 说明: * 参数1位信号名,即我们要处理的信号,在linux中系统信号一共64个,用宏定义表示; * 通过kill -l 可以查看系统所有信号类型; * 其中...
  • wait函数 包含头文件及原型 #include <sys/types.h> /* 提供类型pid_t的定义 */ #include <sys/wait.h> pid_t wait(int *status) 进程一旦调用了wait,就立即阻塞自己,由wait自动分析是否当前进程...
  • 一、wait函数 1.函数功能: ① 阻塞父进程,等待子进程退出 ② 回收子进程残留资源 ③ 获取子进程退出状态(原因)存放在参数中 2.函数包含头文件: #include <sys/types.h> #include <sys/wait.h> 3....
  • wait函数 一个进程在终止时会关闭所有文件描述符,释放在用户空间分配的内存,但它的PCB还保留着,内核在其中保存了一些信息:如果是正常终止则保存着退出状态,如果是异常终止则保存着导致该进程终止的信号是哪个。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,894
精华内容 7,957
关键字:

wait和waitpid函数的区别