Linux

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

文章目录

• • 进程终止
  • ①进程退出
  • 1.正常退出（echo $?）(错误信息获取)
  • 2.进程退出exit函数（stdlib.h）
  • 3.进程退出_exit函数（unistd.h）
  • 4.异常退出(ctrl + c，信号终止)
  • ②进程等待(父进程)
  • 1.必要性
  • 2.wait函数阻塞等待(sys/types.h sys/wait.h)
  • 3.waitpid函数阻塞等待(sys/types.h sys/wait.h)
  • 4.status获取进程的退出状态(位操作/宏获取)(WIFEXITED/WEXITSTATUS)
  • 5.进程非阻塞等待(waitpid)

进程终止 ①进程退出 1.正常退出（echo $?）(错误信息获取)

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

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

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

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

  1 #include  
  2   
  3 #include                                                                       
  4                                               
  5 int main()                                    
  6 {                                             
  7   for(int i=0;i<150;i++)                      
  8   {                                                                                
  9     printf("%d:%sn",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
#include
#include

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

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

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

#include
#include
#include

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                                                                        
  2 #include
  3 #include
  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:%dn",getpid());
 14       sleep(3);
 15     }
 16   }
 17   if(ID>0)                                             
 18   {                                                    
 19     //父进程                                           
 20     while(1)                                           
 21     {                                                  
 22       printf("I am fathern");                         
 23       sleep(2);
 24     }
 25   }
 26   return 0;
 27 }       

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

  1 #include                                                                        
  2 #include
  3 #include
  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:%dn",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 successn");
 26         break;
 27       }
 28       else                                                                
 29       {
 30         printf("Wait Falsen");
 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                                                         
  2 #include
  3 #include
  4 #include
  5 #include
  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=%dn",getpid(),getppid());
 14      sleep(2);
 15     }
 16     exit(1);
 17   }
 18   else 
 19   {                                                                       
 20     printf("Father PID=%dn",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:%dn",ID);
 27     }
 28     else 
 29     {
 30       printf("Waiting for the errorn");                                  
 31     }
 32     printf("Father runingn");
 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                                                        
  2 #include
  3 #include
  4 #include
  5 #include
  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=%dn",getpid(),getppid());
 14      sleep(2);
 15     }
 16     exit(1);
 17   }
 18   else 
 19   {
 20     printf("Father PID=%dn",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:%dn",ID);
 29         printf("status num =%dn",(status>>8)&0xff);
 30         printf("status sig =%dn",(status&0x7f));
 31         break;
 32       }                                                                  
 33       else if(ID==0)
 34       {
 35         //子进程没有结束，但是这次等待成功
 36         printf("Father doing thingsn");
 37         sleep(2);
 38       }
 39       else 
 40       {
 41         printf("Wait faultn");
 42         break;
 43       }                                                                  
 44     }
 45   }
 46   return 0;
 47 }

如上图为非阻塞等待