进程控制（二）进程等待

进程等待

什么是进程等待？？？

进程等待是通过wait/waitpid的方式，让父进程（一般）对子进程进行资源回收的过程。

为什么要进行进程等待？？？

1. 为了解决僵尸进程所带来的内存泄漏的问题
在前面的学习中，我们了解到了一种进程状态叫做僵尸状态（子进程终止时，父进程没有对其的资源进行回收）

2. 确认子进程完成工作的进度
父进程创建子进程，让子进程完成某项工作，那么子进程工作完成的进度等信息父进程是一定要知道的，所以需要通过进程等待来获取子进程的退出信息（两个数字）退出信号、退出码。

进程等待的必要性：
如果子进程退出，父进程不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。

进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。

最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。

父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

进程等待的方法

wait函数

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

我们通过下面代码来演示wait是如何进行等待的

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

void worker()
{
   
  int n = 5;
  while(n)
  {
   
    printf("I am a child process ,pid:%d, ppid:%d, cnt:%d\n", getpid(), getppid(), n);
    n--;
    sleep(1);
  }
}

int main()
{
   
  pid_t id = fork();
  if(id == 0)
  {
   
    //child
    worker();                                                                                                                              
    exit(0);
  }
  else
  {
   
    sleep(10);
    //father
    pid_t rid = wait(NULL);
    if(rid == id)
    {
   
      printf("wait success \n");
    }
  }
  return 0;
}

监视一下：while :; do ps axj | head -1 && ps axj | grep test|grep -v grep;echo "---------------"; sleep 1 ;done

上述代码前五秒钟，父子进程一起运行，其状态为S或R，五秒过后子进程退出但其资源并未回收，所以后面5秒子进程会变成僵尸状态，父进程10s后会打印出上述代码（wait success），打印出来之后也就意味着父进程已经完成了子进程的资源回收，那么子进程的僵尸状态也就消失了。

上述代码证明了：
进程等待能够回收子进程僵尸状态，使其由Z状态变为X状态

wait在等待的时候，父进程又在做什么？

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

void worker()
{
   
  int n = 5;
  while(n)
  {
   
    printf("I am a child process ,pid:%d, ppid:%d, cnt:%d\n", getpid(), getppid(), n);
    n--;
    sleep(1);
  }
}

int main()
{
   
  pid_t id = fork();
  if(id == 0)
  {
   
    //child
    worker();                                                                                                                              
    exit(0);
  }
  else
  {
   
    //father
    printf("wait before\n");
    pid_t rid = wait(NULL);
    printf("wait after\n");
    
    if(rid == id)
    {
   
      printf("wait success \n");
    }
    sleep(10);
  }
  return 0;
}

一开始父子进程同时运行，当子进程在运行这5秒期间，父进程是通过调用了wait方法进程阻塞等待的，五秒期间过后才打印出来wait after,说明这段时间父进程是在等子进程变成僵尸状态，wait自动回收

上述代码证明了：
如果子进程没有退出，父进程必须在wait上进行阻塞等待。直到子进程变为僵尸进程，wait自动回收，返回！
一般来说，父子进程谁先运行是不确定的，但一定是父进程最后退出的。

waitpid函数

返回值：等待成功返回进程pid；等待失败返回 -1；
pid：要等待进程的pid；pid=-1, 等待任一个子进程。与 wait 等效。
status：WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若 WIFEXITED 非零，提取子进程退出码。（查看进程的退出码）
options：WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

其中第三个参数设置为0表示的是阻塞等待。

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

void worker()
{
   
  int n = 5;
  while(n)
  {
   
    printf("I am a child process ,pid:%d, ppid:%d, cnt:%d\n", getpid(), getppid(), n);
    n--;
    sleep(1);
  }
}
int main()
{
   
	pid_t id = fork();
	if(id == 0)
	{
   
		worker();
		exit(10);	
	}
	else
	{
   
		printf("wait before\n");
		int status = 0;
		pid_t rid = waitpid(id, &status, 0);
		printf("wait after\n");
		if(rid == id)
		{
   
			printf("wait success\n");
		} 
		
	}
	return 0;
}

waitpid的第二个参数
上面说过进程等待其实是为了解决子进程僵尸状态所造成的内存泄漏问题，但是进程等待还有第二个目的，就是检查子进程的运行结果，即获取子进程的退出码和终止信号。而这个工作就是有waitpid的第二个参数来做的。


这个status虽然是一个32位的整型，但我们只使用它的低16位，其中，
低八位存储的是终止信号
次低八位存储的是退出状态

上面设置的退出状态是exit(10),也就是10，而10用二进制来表示是1010，放在高8位上则是
0000 1010 0000 0000，而该二进程算出来就是我们上面打印出来的status的值：2560.

退出码:
(status >> 8)&0xFF
退出信号:
status&0x7F

exit sig: 0 代表的信号是0，而信号中并没有0信号，说明运行是成功的！
但是exit code：1，代表结果不正确。
运行正常和结果正确必须exit sig和exit code都为0.
但是当我们的exit sig！=0时，就代表代码运行异常，此时exit code则无意义。

除0错误：

exit sig = 8，对应的就是除零错误。

Q：当一个进程异常了，exit code退出码还有意义吗？
A：无意义（你考试已经作弊了，100分和0分有区别么）

如果我们直接在命令行中kill杀死子进程，信号会是什么呢？

我们发现，使用kill掉子进程后，进程的退出信号就是9,然而当进程由于信号异常终止时,此时进程退出码是无意义的！

waitpid的第三个参数option
option默认为0代表父进程阻塞等待子进程死亡，阻塞等待
就是父进程什么都不干，就在waitpid函数处停下等待子进程变成僵尸进程，然后回收资源。
那么在等待子进程变成僵尸之前，父进程怎样才可以做其他工作，而不是硬等？
非阻塞等待
WNOHANG:等待的时候,以非阻塞的方式等待。

阻塞等待：子进程不退出，wait不返回。
非阻塞等待：往往需要重复调用，轮询+非阻塞，优点：在我们等待子进程变为僵尸的时候，我们也可以做自己的事情，节省时间。

进程的非阻塞式等待：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main()
{
   
	pid_t pid;
	pid = fork();
	if(pid < 0)
	{
   
		printf("%s fork error\n",__FUNCTION__);
		return 1;
	}
	else if( pid == 0 )
	{
    	//child
		printf("child is run, pid is : %d\n",getpid());
		sleep(5);
		exit(1);
	} 
	else
	{
   
		int status = 0;
		pid_t ret = 0;
		do
		{
   
			ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
			if( ret == 0 )
			{
   
				printf("child is running\n");
			}
			sleep(1);
		}while(ret == 0);
		if( WIFEXITED(status) && ret == pid )
		{
   
		printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
		}
		else
		{
   
			printf("wait child failed, return.\n");
			return 1;
		}
	}
	return 0;
}