Linux_进程终止(进程退出,进程等待(阻塞与非阻塞等待))

Posted dodamce

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Linux_进程终止(进程退出,进程等待(阻塞与非阻塞等待))相关的知识,希望对你有一定的参考价值。

进程终止的情况
1.代码运行完毕,结果正确(主函数返回0)
2.代码运行完毕,结果不正确(主函数返回对应错误值)
以上都叫做正常退出
3.代码异常终止(此时主函数的返回值没有意义)
异常退出

进程终止

①进程退出

1.正常退出(echo $?)(错误信息获取)

为了方便观察这里把main函数的返回值设置为10



注意:第二次执行echo $?时是表示上一次命令的返回值为0,代表成功执行了上一次命令

注意:一般将进程正常退出并且结果正确时返回码设置为0
正常退出但结果不正确时返回码设置为非0

非零的退出码在一定范围内对应一种错误,我们可以通过函数strerror获取(这个函数在string.h头文件中)

  1 #include<stdio.h>  
  2   
  3 #include<string.h>                                                                       
  4                                               
  5 int main()                                    
  6 {                                             
  7   for(int i=0;i<150;i++)                      
  8   {                                                                                
  9     printf("%d:%s\\n",i,strerror(i));                                               
 10   }                                                                                
 11   return 0;                                  
 12 }                                             

每一种退出码都对应一种字符串错误信息,帮助用户确认错误信息

2.进程退出exit函数(stdlib.h)

也可以返回进程的退出码,但相比与return,exit在非main函数调用时会被当作进程退出码,而return在非main函数只会被当作函数的返回值


这个程序退出码为9而不是10;因为程序在执行Print函数的时候以经退出了

3.进程退出_exit函数(unistd.h)

在返回程序退出码时与exit相同,但是_exit不会刷新缓冲区,不会关闭流,不会执行用户定义的清理函数
eg:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

void Print()
{
	printf("Hello Linux");
	sleep(3);
	exit(10);
}

int main()
{
	Print();
	return 0;
}

因为printf没有‘\\n’所以不会刷新缓冲区,运行结果为等待三秒后执行exit并且刷新缓冲区。且进程退出码为10.

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

void Print()
{
	printf("Hello Linux");
	sleep(3);
	_exit(10);
}

int main()
{
	Print();
	return 0;
}

因为printf没有‘\\n’所以不会刷新缓冲区,运行结果为等待三秒后执行_exit,
但是_exit不会刷新缓冲区,所以没有文字打在显示器上,进程退出码为10。

4.异常退出(ctrl + c,信号终止)

如果进程存在也i=野指针等错误时进程会退出,但是此时进程退出码没有意义。


信号终止:

这些返回码没有意义,对应错误字符串为未知错误

②进程等待(父进程)

1.必要性

进程等待有其必要性:
1.子进程退出后如果父进程不做处理的话会形成僵尸进程,僵尸进程无法被杀死,占用内存,导致内存泄漏
2.子进程运行结果需要被父进程获取,父进程通过进程等待的方式,回收子进程资源,获取子进程退出信息

2.wait函数阻塞等待(sys/types.h sys/wait.h)

pid_t wait(int*status)

返回值: 成功返回被等待进程的pid,失败返回-1.

其中status为输出型参数,获取子进程退出状态,不关心则可以设置成NULL

在父进程用wait函数等待子进程后,子进程不会进入僵尸状态

  1 #include<stdio.h>                                                                        
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 
  5 int main()
  6 {
  7   pid_t ID=fork();
  8   if(ID==0)
  9   {
 10     //子进程
 11     for(int i=0;i<5;i++)
 12     {
 13       printf("Hello Linux:PID:%d\\n",getpid());
 14       sleep(3);
 15     }
 16   }
 17   if(ID>0)                                             
 18   {                                                    
 19     //父进程                                           
 20     while(1)                                           
 21     {                                                  
 22       printf("I am father\\n");                         
 23       sleep(2);
 24     }
 25   }
 26   return 0;
 27 }       

发现子进程退出后进入 Z 僵尸状态

  1 #include<stdio.h>                                                                        
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 
  5 int main()
  6 {
  7   pid_t ID=fork();
  8   if(ID==0)
  9   {
 10     //子进程
 11     for(int i=0;i<5;i++)
 12     {
 13       printf("Hello Linux:PID:%d\\n",getpid());
 14       sleep(3);
 15     }
 16   }
 17   if(ID>0)                                             
 18   {                                                    
 19     //父进程                                           
 20     while(1)                                           
 21     {
 22       pid_t ret=wait(NULL);//阻塞等待
 23       if(ret>0)
 24       {
 25         printf("wait success\\n");
 26         break;
 27       }
 28       else                                                                
 29       {
 30         printf("Wait False\\n");
 31       }
 32     }
 33   }

如果父进程有wait函数则子进程的退出信息会被父进程接收,子进程不会有僵尸状态

3.waitpid函数阻塞等待(sys/types.h sys/wait.h)

pid_ t waitpid(pid_t pid, int *status, int options)

返回值:当正常返回的时候waitpid返回收集到的子进程的进程ID;

参数:
pid:要等待的进程pid
status:获取进程的退出状态
options:
WNOHANG: 若pid指定的子进程没有结束,则waitpid()函数返回0,不予以等待。若正常结束,则返回该子进程的PID。对应非阻塞等待

0:若pid指定的子进程没有结束,waitpid函数不返回,对应的是阻塞等待

  1 #include<stdio.h>                                                         
  2 #include<stdlib.h>
  3 #include<sys/types.h>
  4 #include<sys/wait.h>
  5 #include<unistd.h>
  6 int main()
  7 {
  8   pid_t id=fork();
  9   if(id==0)
 10   {//子进程
 11     for(int i=0;i<5;i++)
 12     {
 13      printf("SubProcess _PID=%d _PPID=%d\\n",getpid(),getppid());
 14      sleep(2);
 15     }
 16     exit(1);
 17   }
 18   else 
 19   {                                                                       
 20     printf("Father PID=%d\\n",getpid());
 21     //父进程
 22     int status=0;
 23     pid_t ID=waitpid(id,&status,0);
 24     if(ID>0)
 25     {
 26       printf("wait child succeed Child_PID:%d\\n",ID);
 27     }
 28     else 
 29     {
 30       printf("Waiting for the error\\n");                                  
 31     }
 32     printf("Father runing\\n");
 33     sleep(10);
 34   }
 35   return 0;
 36 }

如图,子进程并没有出现 Z 僵尸状态

4.status获取进程的退出状态(位操作/宏获取)(WIFEXITED/WEXITSTATUS)

wait函数与waitpid函数都有输出型参数,在调用完函数后status会获得子进程的退出信息。
将status打印

输出结果为:256,不为1

status为整形,有32比特位

其构成为主要看其低16个比特位

status倒数7位为终止信号区,从倒数16位到倒数第8位为进程退出码区域

status的前16位未利用,无意义

位操作获取进程退出信号

由上面分析可知。
(status>>8)&0XFF即可得到进程退出码

进程退出信号在最后的7个比特位上,所以
status&0X7F即可得到进程退出信号



发现进程退出码与进程与进程退出信息正确

宏获得进程退出码与退出信号
status:
WIFEXITED(status): 若为正常终止子进程返回的状态,则为真。(查看进程是否是正常退出)
WEXITSTATUS(status): 若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)

WIFEXITED(status)=status&0X7F
WEXITSTATUS(status)=(status>>8)&0XFF

注意:
进程只有在进程退出信号为0时,即进程正常运行完。其进程退出码才有意义,否则进程退出码没有意义。

5.进程非阻塞等待(waitpid)

阻塞:在父进程等待子进程中,子进程没有结束返回PID时,父进程不进行任何操作,上面写的代码都是阻塞式等待子进程

非阻塞:在父进程等待子进程中,子进程没有结束返回PID时,父进程会接受0来代表子进程还没有退出,继续执行父进程代码。可以理解为只等待一次,子进程没有结束waitpid()函数返回0,不予以等待

方法:
waitpid第三个参数option为0表示阻塞式等待

当option为WNOHANG时为非阻塞式等待

  1 #include<stdio.h>                                                        
  2 #include<stdlib.h>
  3 #include<sys/types.h>
  4 #include<sys/wait.h>
  5 #include<unistd.h>
  6 int main()
  7 {
  8   pid_t id=fork();
  9   if(id==0)
 10   {//子进程
 11     for(int i=0;i<5;i++)
 12     {
 13      printf("SubProcess _PID=%d _PPID=%d\\n",getpid(),getppid());
 14      sleep(2);
 15     }
 16     exit(1);
 17   }
 18   else 
 19   {
 20     printf("Father PID=%d\\n",getpid());                                  
 21     //父进程
 22     while(1)
 23     {
 24       int status=0;
 25       pid_t ID=waitpid(id,&status,WNOHANG);
 26       if(ID>0)
 27       {
 28         printf("wait child succeed Child_PID:%d\\n",ID);
 29         printf("status num =%d\\n",(status>>8)&0xff);
 30         printf("status sig =%d\\n",(status&0x7f));
 31         break;
 32       }                                                                  
 33       else if(ID==0)
 34       {
 35         //子进程没有结束,但是这次等待成功
 36         printf("Father doing things\\n");
 37         sleep(2);
 38       }
 39       else 
 40       {
 41         printf("Wait fault\\n");
 42         break;
 43       }                                                                  
 44     }
 45   }
 46   return 0;
 47 }

如上图为非阻塞等待

以上是关于Linux_进程终止(进程退出,进程等待(阻塞与非阻塞等待))的主要内容,如果未能解决你的问题,请参考以下文章

Linux-进程控制

Linux进程控制进程创建 | 进程终止 | 进程等待 | 进程替换

Linux进程控制进程创建 | 进程终止 | 进程等待 | 进程替换

Linux进程控制(精讲)

Linux进程控制

《linux设备驱动开发详解》笔记——8阻塞与非阻塞IO