精华内容
下载资源
问答
  • 一、结束进程 首先,我们回顾一下 C 语言中 continue, break, return 的作用: continue: 结束本次循环 break: 跳出整个循环,或跳出 switch() 语句 return: 结束当前函数 而我们可以通过 exit() 或 _exit() 来...

    一、结束进程

    首先,我们回顾一下 C 语言中 continue, break, return 的作用:

    continue: 结束本次循环
    break: 跳出整个循环,或跳出 switch() 语句
    return: 结束当前函数
    而我们可以通过 exit() 或 _exit() 来结束当前进程。
    所需头文件:
    #include <stdlib.h>


    void exit(int value);

    功能:

    结束调用此函数的进程。

    参数:

    status:返回给父进程的参数(低 8 位有效),至于这个参数是多少根据需要来填写。

    返回值:


    所需头文件:

    #include <unistd.h>


    void _exit(int value);

    功能:

    结束调用此函数的进程。

    参数:

    status:返回给父进程的参数(低 8 位有效),至于这个参数是多少根据需要来填写。

    返回值:


    exit() 和 _exit() 函数功能和用法是一样的,无非时所包含的头文件不一样,还有的区别就是:exit()属于标准库函数,_exit()属于系统调用函数。


    下面的例子验证调用 exit() 函数,会刷新 I/O 缓冲区(关于缓冲区的更多详情,请看《浅谈标准I/O缓冲区》):

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(int argc, char *argv[])
    {
    	printf("hi, lh, you are so good"); // 打印,没有换行符"\n"
    	
    	exit(0);      // 结束进程,标准库函数,刷新缓冲区,printf()的内容能打印出来
    	// _exit(0);  // 结束进程,系统调用函数,printf()的内容不会显示到屏幕
    	
    	while(1);	// 不让程序结束
    
    	return 0;
    }

    运行结果:



    上面的例子,结束进程的时候改为调用 _exit(),代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(int argc, char *argv[])
    {
    	printf("hi, mike, you are so good"); // 打印,没有换行符"\n"
    	
    	//exit(0);      // 结束进程,标准库函数,刷新缓冲区,printf()的内容能打印出来
    	_exit(0);  // 结束进程,系统调用函数,printf()的内容不会显示到屏幕
    	
    	while(1);	// 不让程序结束
    
    	return 0;
    }

    运行结果:



    接下来,我们一起验证一下结束函数( return )和结束进程( exit() )的区别。
    测试代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    void fun()
    {
    	sleep(2);
    	
    	exit(0);  // 结束当前进程
    	
    	while(1);
    }
    
    int main(int argc, char *argv[])
    {
    	fun();
    	
    	printf("after fun\n");
    	
    	while(1);	// 不让程序结束
    
    	return 0;
    }

    exit() 是可以结束 fun() 所在的进程,即可让程序结束运行,结果图如下:



    再看如下代码:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    void fun()
    {
    	sleep(2);
    	
    	return;  // 结束 fun() 函数
    	
    	while(1);
    }
    
    
    int main(int argc, char *argv[])
    {
    	fun();
    	
    	printf("after fun\n");
    	
    	while(1);	// 不让程序结束
    
    	return 0;
    }

    运行结果:



    通过上面的运行结果得知,return 的作用只是结束调用 return 的所在函数,只要这个函数不是主函数( main() ),只要主函数没有结束,return 并不能结束进程。



    二、等待进程结束

    当一个进程正常或异常终止时,内核就向其父进程发送 SIGCHLD 信号,相当于告诉父亲他哪个儿子挂了,而父进程可以通过 wait() 或 waitpid() 函数等待子进程结束,获取子进程结束时的状态,同时回收他们的资源(相当于,父亲听听死去儿子的遗言同时好好安葬它)。


    wait() 和 waitpid() 函数的功能一样,区别在于,wait() 函数会阻塞,waitpid() 可以设置不阻塞,waitpid() 还可以指定等待哪个子进程结束。


    所需头文件:

    #include <sys/types.h>

    #include <sys/wait.h>


    pid_t wait(int *status);

    功能:

    等待任意一个子进程结束,如果任意一个子进程结束了,此函数会回收该子进程的资源。


    在每个进程退出的时候,内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息,这些信息主要主要指进程控制块的信息(包括进程号、退出状态、运行时间等)。


    调用 wait() 函数的进程会挂起(阻塞),直到它的一个子进程退出或收到一个不能被忽视的信号时才被唤醒(相当于继续往下执行)。


    若调用进程没有子进程,该函数立即返回;若它的子进程已经结束,该函数同样会立即返回,并且会回收那个早已结束进程的资源。


    所以,wait()函数的主要功能为回收已经结束子进程的资源。


    参数:

    status: 进程退出时的状态信息。


    如果参数 status 的值不是 NULL,wait() 就会把子进程退出时的状态取出并存入其中,这是一个整数值(int),指出了子进程是正常退出还是被非正常结束的。


    这个退出信息在一个 int 中包含了多个字段,直接使用这个值是没有意义的,我们需要用宏定义取出其中的每个字段


    下面我们来学习一下其中最常用的两个宏定义,取出子进程的退出信息:

    WIFEXITED(status)

    如果子进程是正常终止的,取出的字段值非零。

    WEXITSTATUS(status)

    返回子进程的退出状态,退出状态保存在 status 变量的 8~16 位。在用此宏前应先用宏 WIFEXITED 判断子进程是否正常退出,正常退出才可以使用此宏。


    返回值:

    成功:已经结束子进程的进程号

    失败:-1


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


    pid_t waitpid(pid_tpid, int *status, intoptions);

    功能:

    等待子进程终止,如果子进程终止了,此函数会回收子进程的资源。

    参数:

    pid: 参数 pid 的值有以下几种类型:

    pid > 0

    等待进程 ID 等于 pid 的子进程。

    pid = 0

    等待同一个进程组中的任何子进程,如果子进程已经加入了别的进程组,waitpid 不会等待它。

    pid = -1

    等待任一子进程,此时 waitpid 和 wait 作用一样。

    pid < -1

    等待指定进程组中的任何子进程,这个进程组的 ID 等于 pid 的绝对值。


    status: 进程退出时的状态信息。和 wait() 用法一样。


    options: options 提供了一些额外的选项来控制 waitpid()。

    0

    同 wait(),阻塞父进程,等待子进程退出。

    WNOHANG

    没有任何已经结束的子进程,则立即返回。

    WUNTRACED

    如果子进程暂停了则此函数马上返回,并且不予以理会子进程的结束状态。(由于涉及到一些跟踪调试方面的知识,加之极少用到,这里就不多费笔墨了,有兴趣的读者可以自行查阅相关材料)

    返回值:

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


    当正常返回的时候,waitpid() 返回收集到的已经子进程的进程号;


    如果设置了选项 WNOHANG,而调用中 waitpid() 发现没有已退出的子进程可等待,则返回 0;


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


    测试代码:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    
    int main(int argc, char *argv[])
    {
    	pid_t pid;
    	
    	pid = fork(); // 创建进程
    	if( pid < 0 ){ // 出错
    		perror("fork");
    		exit(0);
    	}
    	
    	if( pid == 0 ){// 子进程
    		int i = 0;
    		for(i=0;i<5;i++)
    		{
    			printf("this is son process\n");
    			sleep(1);
    		}
    		
    		_exit(2); // 子进程退出,数字 2 为子进程退出的状态
    		
    	}else if( pid > 0){ // 父进程
    		
    		int status = 0;
    		
    		// 等待子进程结束,回收子进程的资源
    		// 此函数会阻塞
    		// status 某个字段保存子进程调用 _exit(2) 的 2,需要用宏定义取出
    		wait(&status); 
    		// waitpid(-1, &status, 0); // 和 wait() 没区别,0:阻塞
    		// waitpid(pid, &status, 0); // 指定等待进程号为 pid 的子进程, 0 阻塞
    		// waitpid(pid, &status, WNOHANG); // WNOHANG:不阻塞
    		if(WIFEXITED(status) != 0){ // 子进程是否正常终止
    			printf("son process return %d\n", WEXITSTATUS(status));
    		}
    		
    		printf("this is father process\n");	
    	}
    	
    	return 0;
    }

    运行结果:



    源码下载:http://download.csdn.net/download/lianghe_work/8840249

     转自:http://blog.csdn.net/tennysonsky/article/details/45917409




    展开全文
  • Linux进程对于子进程的异步等待

    千次阅读 2017-06-27 16:59:27
    进程为什么等待进程   Linux中,存在多进程、多线程的服务。 进程是如何产生、如何消失的? 首先,打开Linux虚拟机或者系统的时候,系统自己建立一个init进程,这是Linux系统的基础进程,然后init进程再根据...

    父进程为什么等待子进程

      
      Linux中,存在多进程、多线程的服务。


      进程是如何产生、如何消失的?


      首先,打开Linux虚拟机或者系统的时候,系统自己建立一个init进程,这是Linux系统的基础进程,然后init进程再根据一些配置文件决定创建哪些进程,或者我们在终端自己创建一个新进程的时候,如果你有时间,你可以一直追查这个进程的祖祖辈辈,你会发现,他们都指向一个进程,那就是init进程。所以,可以这么说,Linux系统服务中,所有进程都是init的子孙进程。所以,进程的创建是通过创建子进程一个一个实现的。
      但是,一味的创建进程,而不对进程进行合理的管理,必然会造成操作系统的冗余,长时间下来,因为无用进程过多,系统将会崩溃。因为每个进程需要对自己维护一个PCB的结构体,来描述一个进程所有可能用到的资源、标志…所以,这个结构体并不小,且每个进程都自己私有一个,所以对无用进程的PCB管理是很有必要的。
      操作系统把无用或退出进程的PCB管理交给了他的父进程,每个拥有子进程的父进程函数体中都有一个等待操作,需要对他创建的子进程进行管理,毕竟,父亲管儿子天经地义嘛!所以,父进程在执行完自己的所有操作后,会以阻塞或者轮询的方式等待子进程的退出,收到子进程的退出数据之后,通过一定的手段,对子进程的PCB进行资源的释放。
      根据之前的认识,可能一下子就会想到两个函数
      

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

      这两个函数是父进程对子进程的等待函数,成功的返回值都是子进程的pid,直到收到这个pid,系统就会对这个pid对应的PCB进行回收,资源的释放的等操作,保证系统的效率。
      

    wait和waitpid的区别与相同之处

    wait

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

      1、wait函数只会进行阻塞式等待子进程;
      
      2、wait函数只有一个参数status,代表进程的退出方式,如果设置为空(NULL),代表不关心进程的退出方式与退出码。
      status使用bit位表示他的含义,例如,他的次低8为表示进程的退出码,低8位表示进程是否征程退出。为了使用简单,所以操作系统提供了一部分接口。
      

    WIFEXITED(status)//为真时表示进程正常退出
    
    WEXITSTATUS(status)//表示进程退出的退出码

    waitpid

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

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

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

     
      status同wait函数;

    options作用
    WNOHANG即使没有子进程退出,它也会立即返回,不会像wait那样永远等下去。(即轮询等待)
    WUNTRACED跟踪

      
      所以,父进程等待子进程的函数就是这两个函数,虽然waitpid有轮询方式等待子进程,但是隔一段时间来轮询检查一次子进程,还是很浪费资源,所以我们需要更简单、更省资源的做法。
      
      

    子进程的退出时对父进程发出信号

      子进程的退出其实是会给父进程发出一个信号的,恰巧在kill的信号列表里,可以发现这个信号。
      这里写图片描述
      SIGCHLD是不是很眼熟,那不就是 signal 和 child的简写吗?所以有理由相信,子进程退出时会对父进程发出一个SGICHLD的信号。所以现在使用signal函数对SIGCHLD进行一次捕捉
      

    对子进程退出时信号的捕捉

    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    void handler(int sig)
    {
        printf("%d\n",sig);
    }
    
    int main()
    {
        int i=1;
        for(;i<=31;i++){
            signal(i,handler);
        }
        printf("\n");
        pid_t id=fork();
        if(id<0){
            perror("fork");
            exit(1);
        }else if(id==0){
            printf("i am a child:%d,my father is %d\n",getpid(),getppid());
            exit(2);
        }
        printf("i am father:%d\n",getpid());
        sleep(1);
        return 0;
    }
    

    输出结果:
    这里写图片描述

    捕捉子进程SIGCHLD后进行等待

      现在已经验证子进程退出时会对父进程发出一个SIGCHLD的信号,所以我们可以对这个信号进行捕捉,自定义的信号处理方式表位等待一个子进程,所以这就省去了对于一个子进程的阻塞等待或者轮询等待时资源的耗费。
      代码实现
      

    #include <stdio.h>
    #include <signal.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    void handler(int id)
    {
        int status;
        if (waitpid(-1,&status,0)<0 ){
            perror("waitpid");
            exit(3);
        }
        printf("handler func wait success!\n");
    }
    
    int main()
    {
        signal(SIGCHLD,handler);
        pid_t id=fork();
        if(id<0){
            perror("fork");
            exit(1);
        }else if(id==0){//child
            printf("i am child :%d\n",getpid());
            exit(2);
        }else{
            printf("i am father :%d\n",getpid());
            sleep(1);
        }
        return 0;
    }
    

    输出结果
    这里写图片描述


      
      如果在handler函数中将判断的if条件改为while循环则可以等待多个子进程。
      

    void handler(int id)
    {
        int status;
        while (waitpid(-1,&status,0) ){
           printf("handler func wait success!\n");
        }
    }
    展开全文
  • Linux父进程等待进程结束

    千次阅读 2013-11-19 20:57:20
    进程一旦调用了wait,就立即阻塞自己,由wait自动分析是否当前进程的某个子进程已经退出。如果让它找到了这样一个已经变成僵尸的子进程,wait就会收集这个子进程的信息,并把它彻底销毁后返回;如果没有找到这样一...
    wait()的函数原型是:
    
    #include <sys/types.h>  
    #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。


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


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


    #include <stdlib.h>
    #include <stdio.h>
    #include <signal.h>
    #include <unistd.h>
    #include <sys/wait.h>
    void f(){
    printf("THIS MESSAGE WAS SENT BY PARENT PROCESS..\n");
    }


    main(){
    int i,childid,status=1,c=1;
    signal(SIGUSR1,f); //setup the signal value
    i=fork(); //better if it was: while((i=fork)==-1);
    if (i){
    printf("Parent: This is the PARENT ID == %d\n",getpid());
    sleep(3);
    printf("Parent: Sending signal..\n");
    kill(i,SIGUSR1); //send the signal


    //status is the return code of the child process
    wait(&status);
    printf("Parent is over..status == %d\n",status);


    //WIFEXITED return non-zero if child exited normally 
    printf("Parent: WIFEXITED(status) == %d\n",WIFEXITED(status));


    //WEXITSTATUS get the return code
    printf("Parent: The return code WEXITSTATUS(status) == %d\n",WEXITSTATUS(status));
    } else {
    printf("Child: This is the CHILD ID == %d\n",getpid());
    while(c<5){
    sleep(1);
    printf("CHLID TIMER: %d\n",c);
    c++;
    }
    printf("Child is over..\n");
    exit(2);
    }
    }


    输出:
    Child: This is the CHILD ID == 8158
    Parent: This is the PARENT ID == 8157
    CHLID TIMER: 1
    CHLID TIMER: 2
    Parent: Sending signal..
    THIS MESSAGE WAS SENT BY PARENT PROCESS..
    CHLID TIMER: 3
    CHLID TIMER: 4
    Child is over..
    Parent is over..status == 512
    Parent: WIFEXITED(status) == 1 //正常退出
    Parent: The return code WEXITSTATUS(status) == 2 //拿到子进程返回值
    展开全文
  • 主进程等待进程结束

    千次阅读 2017-12-02 17:12:00
    进程先于父进程退出时,如果父进程没有调用wait和waitpid函数,子进程就会进入僵死状态。如果父进程调用了wait或waitpid函数,就不会使子进程变为僵尸进程。这两个函数的声明如下: #include #include pid_t ...

          子进程先于父进程退出时,如果父进程没有调用wait和waitpid函数,子进程就会进入僵死状态。如果父进程调用了wait或waitpid函数,就不会使子进程变为僵尸进程。这两个函数的声明如下:

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


          (1)wait函数使父进程暂停执行,直到它的一个子进程结束为止。该函数的返回值是终止运行的子进程的PID。参数statloc所指向的变量存放子进程的退出码,即从子进程的main函数返回的值或子进程中exit函数的参数。如果statloc不是一个空指针,状态信息将被写入它指向的变量。

          (2)waitpid也用来等待子进程的结束,但它用于等待某个特定进程结束。参数pid指明要等待的子进程的PID。参数statloc的含义与wait函数中的statloc相同。options参数允许用户改变waitpid的行为,若将该参数赋值为WNOHANG,则使父进程不被挂起而立即返回并执行其后的代码。


          注意:(1)wait等待第一个终止的子进程,而waitpid则可以指定等待特定的子进程。

                    (2)waitpid提供了一个wait的非阻塞版本。有时希望取得一个子进程的状态,但不想使父进程阻塞,waitpid提供了一个这样的选项:WNOHANG,它可以使调用者不阻塞。


    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    int main()
    {
    	pid_t	pid;
    	char  	*msg;
    	int   	k;
    	int   	exit_code;
    
    	printf("Study how to get exit code\n");
    	pid = fork();
    	switch(pid) {
    		case 0:
    			//子进程
    			msg = "Child process is running";
    			k = 5;
    			exit_code = 37;
    			break;
    		case -1:
    			perror("Process creation failed\n");
    			exit(1);
    		default:
    			//父进程
    			exit_code = 0;
    			break;
    	}
    
    	// 父进程等待子进程结束
    	if(pid != 0) {  
    		int 	stat_val;
    		pid_t 	child_pid;
    		
    		child_pid = wait(&stat_val);
    		
    		printf("Child process has exited, pid = %d\n",child_pid);
    		if(WIFEXITED(stat_val))
             		printf("Child exited with code %d\n",WEXITSTATUS(stat_val));
           		else
            		printf("Child exited abnormally\n");
    	}
    	// 子进程暂停5秒,在这个过程中可以运行命令ps aux查看父进程状态
    	else {
    		while(k-->0) {
    			puts(msg);
    			sleep(1);
    		}
    	}
    
    	// 父子进程都会执行以下这段代码。父进程的exit_code是0,而子进程的exit_code是37
    	exit(exit_code);
    }
    


          程序运行结果如下:



          父进程调用wait后被挂起等待(此时打开另外一个终端,输入命令ps aux可以看到父进程的状态为S),直到子进程结束为止。子进程正常结束后,wait函数返回刚刚结束运行的子进程的pid,宏WEXITSTATUS获取子进程的退出码(本例中设置为37)。




    展开全文
  • LInux进程等待之wait() & waitpid()

    千次阅读 2018-03-29 17:12:23
    进程等待 之前说,子进程退出,父进程如果不管不顾,就可能造成“僵尸进程”的问题,进而造成内存泄露,进而,进程一旦变成僵尸状态,杀人不眨眼的”kill -9”也无能为力,因为谁也没有办法杀死一个已经死去的...
  • Linux系统编程——进程的控制:结束进程、等待进程结束,相关教程如下: http://blog.csdn.net/tennysonsky/article/details/45917409
  • linux c 等待所有子进程结束

    千次阅读 2013-03-08 20:20:04
    当子进程结束时,它会向父进程发送SIG_CHLD信号,然后父进程使用wait waitpid waittid函数来捕获某一子进程的退出状态。当需要等待所有子进程全部退出时,我们可以设置SIG_CHLD为SIG_IGN,然后使用wait来阻塞直到...
  • 进程等待进程退出并收集子进程退出状态 1.父进程为什么要等待进程退出? 创建子进程目的:------干活 我们要知道干活结束没。 子进程退出状态不被收集,变成僵尸进程 等待:wait,waitpid函数: #include &...
  • Linux下父进程异步等待进程

    千次阅读 2017-07-17 10:00:56
      我们可以使用wait和waitpid函数清理僵死进程,父进程可以阻塞等待进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式,父进程阻塞了就不能处理自己的工作了;采用第二种...
  • int status; pid_t t = fork(); if(t){  waitpid(t, &...//父进程和子进程均执行完毕后继续执行下去   分析过程: if 和 else 还是选择分支。 主要的原因是,fork() 函数调用一次,返回...
  • Linux中fork函数是非常重要的函数,会创建子进程,原进程是父进程。 子进程返回0,父进程返回子进程id。 进程调用fork,当控制转移到内核中的fork代码后,内核做以下动作: 分配新的内存块和内核数据给子进程...
  • LinuxLinux进程的创建与管理

    万次阅读 多人点赞 2018-07-27 19:21:29
    Linux系统中,除了系统启动之后的第一个进程由系统来创建,其余的进程都必须由已存在的进程来创建,新创建的进程叫做子进程,而创建子进程进程叫做父进程。那个在系统启动及完成初始化之后,Linux自动创建的进程...
  • pid_t r_wait(int * stat_loc) { int revalue; while(((revalue = wait(stat_loc)) == -1) && (errno == EINTR));//如果等待的过程中被一个不可...服务退出之前父进程等待进程的调用方法: while(r_wait(NULL)
  • 运行指定的命令,如果在指定时间后仍在运行,则杀死该进程。用来控制程序运行的时间。 使用方法 timeout [选项] 数字[后缀] 命令 [参数]... 后缀”s”代表秒(默认值),”m”代表分,”h”代表小时,”d”代表...
  • Linux_判断进程是否正常结束

    千次阅读 2018-12-01 18:21:15
    status的值即为exit(a)函数里的a值,代码中列举进程正常结束。 #include &lt;stdio.h&gt; #include &lt;fcntl.h&gt; #include &lt;stdlib.h&gt; int main() { pid_t pid; int status...
  • 二、父进程必须监控子进程的运行状态,等待进程退出后,使用wait()进行关闭,否则,如果父进程先退出,子进程就没有父亲了,就变成了僵尸进程,此时退出时,就会被系统进程init监控到,然后由系统进程init进行关闭...
  • Linux结束进程的命令

    千次阅读 2016-03-15 17:56:43
    Linux结束进程的命令  1. kill  作用:根据进程号杀死进程  用法: kill [信号代码] 进程ID  举例:  [root@localhost ~]# ps auxf |grep httpd  注意:kill -9 来强制终止退出  举例 [root@...
  • 等待结束的方法:  2.1、使用 wait 命令 #!/bin/bash sleep 10 &amp;&amp; echo "1" &gt;&gt; s.lock &amp; sleep 12 &amp;&amp; echo "1" &gt;&gt; ...
  • 等待进程结束wait()和waitpid()

    千次阅读 2018-02-02 15:07:12
    父子进程有时需要简单的进程间同步,如父进程等待进程结束linux提供了以下两个等待函数:wait(),waitpid().需要包含头文件:#include &lt;sys/types.h&gt;#include &lt;sys/wait.h&gt;1) pid...
  • 创建进程,等待进程,进程终止
  • Linux 进程控制——等待队列详解

    万次阅读 多人点赞 2016-06-29 21:48:24
    一、什么是睡眠  对于一个进程"睡眠"意味着什么? 当一个进程被置为睡眠, ... 一个睡着的进程已被搁置到系统的一边, 等待以后发生事件.  LDD3说得很玄乎,睡眠是“自愿调度”,其实就是将当前进程的状态设置为 TASK
  • Linux进程编程(典藏、含代码)

    千次阅读 多人点赞 2020-02-03 21:44:40
    目录 一、基础知识 1.1、进程的概念 1.2、多进程(任务)并行的实现 1.3、重要指令 1.4、父子进程和进程ID 二、多进程编程 2.1创建子进程 (fork/...2.3等待进程结束并资源回收 2.3.1 wait函数 2.3.2 waitpi...
  • linux C进程 进程等待wait与waitpid函数

    千次阅读 2017-11-26 12:20:04
    1. 孤儿进程:父进程先于子进程结束,则子进程成为孤儿进程,子进程的父进程变为init进程 。 2. 僵尸进程:子进程终止了,父进程尚未回收子进程,子进程残留资源(PCB)存放于内核中,子进程变成僵尸(Zombie)
  • LinuxLinux进程简介及其五种状态

    万次阅读 2018-07-24 21:42:36
    由操作系统定义,并由操作系统所操控的一个特殊的数据结构实例叫做进程。它连接了用户代码,拥有代码运行所需的独立内存空间,在调度器的调度下使用分配给它的处理器时间片来运行。   进程及其私有内存空间 进程...
  • 一文读懂Linux进程进程组、会话、僵尸

    千次阅读 多人点赞 2020-02-24 08:21:00
    作者简介 herongwei,北交硕士毕业,现就职于搜狗公司,后端开发工程师。从事 C++,Golang ,Linux 后端开发。追求技术,热爱编程与分享,希望能和大家多多交流学习~座右...
  • Linux进程控制及进程间通信

    千次阅读 2019-06-23 23:16:35
    熟悉Linux进程控制编程,掌握多进程程序中相关函数的作用,理解Linux中多进程编程的步骤;熟悉进程间通信中管道的使用。 实验内容 熟悉Linux进程控制编程; 熟悉Linux进程间通信的6种方式; 掌握Linux进程有关的函数...
  • linux 查看进程命令

    万次阅读 2020-02-10 17:55:56
    Linux 查看进程之PS命令 要对进程进行检测和控制,首先必须要了解当前进程的情况,也就是需要查看当前进程运行状态。Linux 系统中 我们可以使用 ps 命令查看进程。...进程是否结束进程有没有僵尸、哪...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,806
精华内容 50,722
关键字:

linux等待进程结束

linux 订阅