LINUX下如何避免僵尸进程

Linux下如何避免僵尸进程的产生

1. 什么是僵尸进程

    比如进程采用exit()退出的时候，操作系统会进行一些列的处理工作，包括关闭打开的文件描述符、占用的内存等等，但是，操作系统也会为该进程保留少量的信息，比如进程ID号等信息，因而占用了系统的资源。在一种极端的情况下，档僵尸进程过多的时候，占用了大量的进程ID，系统将无法产生新的进程，相当于系统的资源被耗尽。
    所以，避免僵尸进程的产生具有极其重要的意义。一般来讲避免僵尸进程主要包含以下几种方法：

1. 父进程使用wait()或者waitpid()之类的函数等待子进程退出
2. 父进程先产生一个子进程，然后子进程再产生一个孙子进程，子进程在孙子进程之前退出。
3. 使用信号函数sigaction为SIGCHLD设置wait处理函数。

2. wait（）函数

    wait()函数的使用最为简单，源代码如图所示：
   
    父进程创建子进程后30s调用wait()函数，等待子进程退出，回收子进程的资源，这也意味着子进程将会成为僵尸进程30s-5s=25s。
    运行该程序后，打开终端，查看进程状态，该图显示的有一个进程的标志为Z，表示该进程为僵尸进程（Zombie）。  
    
    当父进程调用wait()函数后，子进程的资源被回收，僵尸进程的标志被去掉了.如下图所示：
    

3. 两次fork()创建孙子进程

    2中的方法比较简洁，但是有个问题就是子进程如果处理的时间比较长的话，主进程会被挂起。比如：

1.     socket()
2.     bind()
3.     listen()
4.     while(1)
5.     {
6.          accept()
7.         if(fork()==0)
8.         {
9.             while(1)
10.             {
11.                 read()
12.                 process()
13.                 write()
14.             }
15.             close()
16.             exit
17.         }
18.         //wait()///<如果这里父进程进行wait()操作，则很有可能再此处挂起，而如果不进行wait()操作，则此处又产生了僵尸进程。
19.     }

    对于这样的情况可以采取连续fork()两次的方法。简而言之，首先父进程首先创建子进程，子进程创建孙子进程，由孙子进程处理事务，
而子进程再创建完孙子进程后，就退出。此时，孙子进程的父进程，也就是子进程退出了，因此孙子进程变为了一个孤儿进程，Linux进程处理
孤儿的进程的方式，是init进程接管孤儿进程，而init进程的子进程不会成为僵尸进程。
    所以上述的伪代码可以写为：

1.     if(fork() ==0 )
2.     {
3.             if(fork()==0)
4.             {
5.                     /*孙子进程在这里处理事务*/
6.                     process();
7.                     close()
8.                     exit()
9.             }
10.             else
11.             {
12.                 /*子进程再这里退出，使得孙子进程成为init进程的儿子，从而避免僵尸进程的产生*/
13.                 close()
14.                 exit()///<子进程在此退出
15.             }
16.     }
17.     else
18.     {
19.           ///<爷爷进程进入下一轮的处理。
20.     }

4. 采用信号量处理函数

    还有一种方法就是采用信号量处理函数来处理这种情况，该过程的代码可以表示为：

1. #include    
2. #include    
3. #include    
4. #include    
5. #include    
6. #include    
7. int num_clients = 0;  
8. int dead_clients = 0;  
9. void sig_chld_handler(int sig) {  
10.     pid_t pid;  
11.     if (sig == SIGCHLD) {  
12.         pid = wait(NULL);  
13.         printf("A child dead, current child number: %d, id: %d/n", ++dead_clients, pid);  
14.     }  
15. }  
16. int main(int argc, char **argv) {  
17.     pid_t pid;  
18.     signal(SIGCHLD, sig_chld_handler);  
19.     for (int i = 0; i < 30; i++) {  
20.         if ((pid = fork()) == 0) {  
21.             exit(0);  
22.         } else if (pid > 0) {  
23.             printf("A child created, current child number: %d, id: %d/n", ++num_clients, pid);  
24.         }  
25.     }  
26.     sleep(10);  
27.     return 0;  
28. }

    父进程首先注册一个信号处理函数signal(SIGCHLD, sig_chld_handler)，然后每当子进程退出的时候父进程都会受到SIGCHLD信号，
触发sig_chld_handler()函数，调用wait()函数等待子进程的退出。

5.总结

上述三种方法都有好处，个人比较倾向于连续两次fork()，这种方式我个人认为是最为简洁的方式。