孤儿进程，僵尸进程，父等子死

一.孤儿进程

1.什么是 孤儿进程
如果一个子进程的父进程先于子进程 结束， 子进程就成为一个孤儿进程，它由 init 进程收养，成为 init 进程的子进程。
2.那么如何让一个进程变为一个孤儿进程呢？
我们可以先创建一个进程，然后杀死其父进程，则其就变成了孤儿进程。

		pid =  fork();
		if(pid > 0) {
		                 exit(0);
		}

父进程运行结束，但子进程还在运行（未运行结束）的子进程就称为孤儿进程（Orphan Process）。孤儿进程最终会被 init 进程（进程号为 1 ）所收养，并由 init 进程对它们完成状态收集工作。
孤儿进程是没有父进程的进程，为避免孤儿进程退出时无法释放所占用的资源而变为僵尸进程（什么是僵尸进程，请看《特殊进程之僵尸进程》），进程号为 1 的 init 进程将会接受这些孤儿进程，这一过程也被称为“收养”。init 进程就好像是一个孤儿院，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为 init ，而 init 进程会循环地 wait() 它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init 进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
注意：如果是64位系统，孤儿进程的父进程号并不是 1 号。

孤儿进程的测试例子：

		#include <stdio.h>
		#include <stdlib.h>
		#include <unistd.h>
		#include <errno.h>
		 
		int main()
		{
		    pid_t  pid;
		    //创建进程
		    pid = fork();
			
		    if (pid < 0){ // 出错
		        perror("fork error:");
		        exit(1);
		    }else if (pid == 0){//子进程
				sleep(2); // 保证父进程先结束
				
				printf("son proess: [son id] = %d, [son's father id] = %d\n", getpid(), getppid());
				
				exit(0);
				
		    }else if(pid > 0){ // 父进程
				printf("father process, i am exited\n");
				
				exit(0);
			}
			
		    return 0;
		}

僵尸进程（Zombie Process）

进程已运行结束，但进程的占用的资源未被回收，这样的进程称为僵尸进程。

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。 但是仍然为其保留一定的信息，这些信息主要主要指进程控制块的信息（包括进程号、退出状态、运行时间等）。直到父进程通过 wait() 或 waitpid() 来获取其状态并释放（具体用法，请看《等待进程结束》）。 这样就会导致一个问题，如果进程不调用wait() 或 waitpid() 的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程.此即为僵尸进程的危害，应当避免。

子进程已运行结束，父进程未调用 wait() 或 waitpid() 函数回收子进程的资源是子进程变为僵尸进程的原因。

僵尸进程测试程序如下：

	#include <stdio.h>
	#include <unistd.h>
	#include <errno.h>
	#include <stdlib.h>
	 
	int main(int argc, char *argv[])
	{
	    pid_t pid;
	    pid = fork();	//创建进程
		
	    if( pid < 0 ){ // 出错
	        perror("fork error:");
	        exit(1);
	    }else if( 0 == pid ){ // 子进程
		
	        printf("I am child process.I am exiting.\n");
			printf("[son id]: %d\n", getpid() );
			
	        exit(0);
	    }else if( pid > 0){ // 父进程
			// 父进程没有调用 wati() 或 watipid() 
			sleep(1); // 保证子进程先运行
			printf("I am father process.I will sleep two seconds\n");
			printf("[father id]: %d\n", getpid() );
			
			while(1); // 不让父进程退出
		}
		
	    return 0;
	}

如何避免僵尸进程？
1）最简单的方法，父进程通过 wait() 和 waitpid() 等函数等待子进程结束，但是，这会导致父进程挂起。具体用法，请看下面的父等子死。

2）如果父进程要处理的事情很多，不能够挂起，通过 signal() 函数人为处理信号 SIGCHLD ， 只要有子进程退出自动调用指定好的回调函数，因为子进程结束后， 父进程会收到该信号 SIGCHLD ，可以在其回调函数里调用 wait() 或 waitpid() 回收。关于信号的更详细用法，请看《信号中断处理》。

测试代码如下：

	#include <stdio.h>
	#include <unistd.h>
	#include <errno.h>
	#include <stdlib.h>
	#include <signal.h>
	 
	void sig_child(int signo)
	{
	    pid_t  pid;  
		 
	    //处理僵尸进程, -1 代表等待任意一个子进程, WNOHANG代表不阻塞
	    while( (pid = waitpid(-1, NULL, WNOHANG)) > 0 ){
			printf("child %d terminated.\n", pid);
		}
	}
	 
	int main()
	{
	    pid_t pid;
		
	    // 创建捕捉子进程退出信号
		// 只要子进程退出，触发SIGCHLD，自动调用sig_child()
	    signal(SIGCHLD, sig_child);
		
	    pid = fork();	// 创建进程
		
	    if (pid < 0){ // 出错
	        perror("fork error:");
	        exit(1);
	    }else if(pid == 0){ // 子进程
	        printf("I am child process,pid id %d.I am exiting.\n",getpid());
	        exit(0);
			
	    }else if(pid > 0){ // 父进程
			sleep(2);	// 保证子进程先运行
			printf("I am father, i am exited\n\n");
			system("ps -ef | grep defunct"); // 查看有没有僵尸进程
		
		}
		
	    return 0;
	}

3）如果父进程不关心子进程什么时候结束，那么可以用signal（SIGCHLD, SIG_IGN）通知内核，自己对子进程的结束不感兴趣，父进程忽略此信号，那么子进程结束后，内核会回收， 并不再给父进程发送信号。关于信号的更详细用法，请看《信号中断处理》。

测试代码如下：

			#include <stdio.h>
			#include <unistd.h>
			#include <errno.h>
			#include <stdlib.h>
			#include <signal.h>
			 
			int main()
			{
			    pid_t pid;
				
			    // 忽略子进程退出信号的信号
				// 那么子进程结束后，内核会回收， 并不再给父进程发送信号
			    signal(SIGCHLD, SIG_IGN);
				
			    pid = fork();	// 创建进程
				
			    if (pid < 0){ // 出错
			        perror("fork error:");
			        exit(1);
			    }else if(pid == 0){ // 子进程
			        printf("I am child process,pid id %d.I am exiting.\n",getpid());
			        exit(0);
					
			    }else if(pid > 0){ // 父进程
					sleep(2);	// 保证子进程先运行
					printf("I am father, i am exited\n\n");
					system("ps -ef | grep defunct"); // 查看有没有僵尸进程
				
				}
				
			    return 0;
			}

父等子死

当一个进程正常或异常终止时，内核就向其父进程发送 SIGCHLD 信号，相当于告诉父亲他哪个儿子挂了，而父进程可以通过 wait() 或 waitpid() 函数等待子进程结束，获取子进程结束时的状态，同时回收他们的资源（相当于，父亲听听死去儿子的遗言同时好好安葬它）。
wait() 和 waitpid() 函数的功能一样，区别在于，wait() 函数会阻塞，waitpid() 可以设置不阻塞，waitpid() 还可以指定等待哪个子进程结束。
所以，wait()函数的主要功能为回收已经结束子进程的资源。

	#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;
	}