执行system后产生defunct，高手进来分析下

morris2600

程序中通过system（）调用另一个可执行程序， 如：
if (0 != system("./exe_process args"))
{
     DEBUGLOG("error");
}

但在长期运行中经常发现出现 exe_process 的defunct进程， 看了下system的源码， 无非就是fork, exec, waitpid

不明白为什么会出现僵尸进程

补充： 此程序运行时内存可能有限， 不知道是否有影响

openspace

能把源码贴一下吗？

morris2600

源码几乎就是我上面贴的样子， 就是在一个函数里调用system，没什么特别的

yjh777

僵尸进程产生的条件你知道吗？？

morris2600

感谢关注

所谓僵尸进程，应该是子进程退出了， 而父进程并没有处理子进程的退出（waitpid或SIGCHLD等）， 导致子进程的部分资源没有完全销毁而产生的吧

理解不对的地方还望指教

我的问题是， system的源码里是处理了子进程的推出的， 不明白什么情况下会产生僵尸

duanjigang

两次fork执行你的exe

duanjigang

1. 
   
2. int startProc(const struct proc_struct* proc)
   
3. {
   
4.     if(!proc)
   
5.         {
   
6.                 return 0;
   
7.         }
   
8.         int pid = fork();
   
9.         if(pid == 0)
   
10.         {
    
11.                 char*szParam[] = {proc->cmdline, proc->param, NULL};
    
12.                 pid = fork();
    
13.                 if(pid == 0)
    
14.                 {
    
15.                         execvp(proc->cmdline, szParam);
    
16.                         exit(0);
    
17.                 }else
    
18.                 {
    
19.                         exit(0);
    
20.                 }
    
21.                
    
22.         }else
    
23.         {
    
24.                 wait(NULL);
    
25.                 return 1;               
    
26.         }       
    
27. }
    

复制代码

http://linux.chinaunix.net/bbs/thread-1021030-1-1.html

morris2600

感谢楼上解答

其实我的本意是想知道为什么system会产生僵尸进程， 比如有人碰到过、或者能从原理上讲明白

当然如果解决不了的话可能会考虑改为fork两次

duanjigang

感谢楼上解答

其实我的本意是想知道为什么system会产生僵尸进程， 比如有人碰到过、或者能从原理上讲明白 ...
morris2600 发表于 2010-07-23 08:54

首先你可以看下《linux内核设计与实现》大概前几章，有一章讲这个的。另外，下面
这篇文章说的也很好。
http://hi.baidu.com/kobetec/blog ... dca883e950cdf4.html
怎样避免产生僵尸进程2008-02-20 17:09怎样避免产生僵尸进程
摘录于: <<Advanced Programming in the UNIX&reg; Environment: Second Edition>> By W. Richard Stevens, Stephen
1.什么是僵尸进程?
In UNIX System terminology, a process that has terminated,but whose

parent has not yet waited for it, is called a zombie.

在UNIX 系统中,一个进程结束了,但是他的父进程没有等待(调用wait / waitpid)他,

那么他将变成一个僵尸进程.

但是如果该进程的父进程已经先结束了,那么该进程就不会变成僵尸进程,

因为每个进程结束的时候,系统都会扫描当前系统中所运行的所有进程,

看有没有哪个进程是刚刚结束的这个进程的子进程,如果是的话,就由Init

来接管他,成为他的父进程,从而保证每个进程都会有一个父进程.

而Init进程会自动wait 其子进程,因此被Init接管的所有进程都不会变成僵尸进程.

2. 僵尸进程的危害
由于子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程

到底什么时候结束. 那么不会因为父进程太忙来不及waid子进程,或者说不知道

子进程什么时候结束,而丢失子进程结束时的状态信息呢?

不会.因为UNIX提供了一种机制可以保证 只要父进程想知道子进程结束时的状态信息,

就可以得到. 这种机制就是:

在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等.

但是仍然为其保留一定的信息(包括进程号the process ID,退出状态the termination

status of the process,运行时间the amount of CPU time taken by the process等),

直到父进程通过wait / waitpid来取时才释放.

但这样就导致了问题,如果你进程不调用wait / waitpid的话, 那么保留的那段信息就不会

释放,其进程号就会一定被占用,但是系统所能使用的进程号是有限的,如果大量的产生

僵死进程,将因为没有可用的进程号而导致系统不能产生新的进程.

此即为僵尸进程的危害,应当避免.

3.僵尸进程的避免
1、父进程通过wait和waitpid等函数等待子进程结束，这会导致父进程挂起

2. 如果父进程很忙，那么可以用signal函数为SIGCHLD安装handler，因为子进程结束后，

父进程会收到该信号，可以在handler中调用wait回收


3. 如果父进程不关心子进程什么时候结束，那么可以用signal（SIGCHLD, SIG_IGN）

通知内核，自己对子进程的结束不感兴趣，那么子进程结束后，内核会回收，

并不再给父进程发送信号

4. 还有一些技巧，就是fork两次，父进程fork一个子进程，然后继续工作，子进程fork一

个孙进程后退出，那么孙进程被init接管，孙进程结束后，init会回收。不过子进程的回收

还要自己做。 下面就是Stevens给的采用两次folk避免僵尸进程的示例.
Example
Recall our discussion in Section 8.5 about zombie processes. If we want to write a process so that it forks a child but we don't want to wait for the child to complete and we don't want the child to become a zombie until we terminate, the trick is to call fork twice. The program in Figure 8.8 does this.

We call sleep in the second child to ensure that the first child terminates before printing the parent process ID. After a fork, either the parent or the child can continue executing; we never know which will resume execution first. If we didn't put the second child to sleep, and if it resumed execution after the fork before its parent, the parent process ID that it printed would be that of its parent, not process ID 1.

1. 
   
2. #include "apue.h"
   
3. #include <sys/wait.h>
   
4. 
   
5. int
   
6. main(void)
   
7. ...{
   
8.      pid_t    pid;
   
9. 
   
10.     if ((pid = fork()) < 0) ...{
    
11.          err_sys("fork error");
    
12.      } else if (pid == 0) ...{     /**//* first child */
    
13.         if ((pid = fork()) < 0)
    
14.              err_sys("fork error");
    
15.         else if (pid > 0)
    
16.              exit(0);    /**//* parent from second fork == first child */
    
17.         /**//*
    
18.           * We're the second child; our parent becomes init as soon
    
19.           * as our real parent calls exit() in the statement above.
    
20.           * Here's where we'd continue executing, knowing that when
    
21.           * we're done, init will reap our status.
    
22.          */
    
23.          sleep(2);
    
24.          printf("second child, parent pid = %d ", getppid());
    
25.          exit(0);
    
26.      }
    
27.    
    
28.     if (waitpid(pid, NULL, 0) != pid)  /**//* wait for first child */
    
29.          err_sys("waitpid error");
    
30. 
    
31.     /**//*
    
32.       * We're the parent (the original process); we continue executing,
    
33.       * knowing that we're not the parent of the second child.
    
34.      */
    
35.      exit(0);
    
36. }
    
37. 
    

复制代码

duanjigang

根据理论我们做个测试的例子。
子进程要执行的程序test_prog

1. 
   
2. //test.c
   
3. #include <stdio.h>
   
4. int main()
   
5. {
   
6.         int i = 0;
   
7.         for (i = 0 ; i < 10; i++)
   
8.         {
   
9.                 printf ("child time %d\n", i+1);
   
10.                 sleep (1);
    
11.         }
    
12.         return 0;
    
13. }
    

复制代码

父进程father的代码father.c

1. 
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <sys/types.h>
   
5. #include <sys/wait.h>
   
6. int main()
   
7. {
   
8.         int pid = fork ();
   
9.         if (pid == 0)
   
10.         {
    
11.                 system ("./test_prog");
    
12.                 _exit (0);
    
13.         }else
    
14.         {
    
15.                 int i = 0;
    
16.                 /*
    
17.                                 int status = 0;
    
18.                 while (!waitpid(pid, &status, WNOHANG))
    
19.                 {
    
20.                         printf ("father waiting%d\n", ++i);
    
21.                         sleep (1);
    
22.                 }*/
    
23.                 while (1)
    
24.                 {
    
25.                         printf ("father waiting over%d\n", ++i);
    
26.                         sleep (1);
    
27.                 }
    
28.                 return 0;
    
29.         }
    
30. 
    
31. }
    

复制代码

执行./father,当子进程退出后，由于父进程没有对它的退出进行关注，会出现僵尸进程

1. 
   
2. 20786 pts/0    00:00:00 father
   
3. 20787 pts/0    00:00:00 father <defunct>
   

复制代码