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

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

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>
   

复制代码

duanjigang

如果你把上面father.c中的waitpid的注释打开，会出现如下现象。
子进程退出的一瞬间，父进程在sleep还未调用waitpid,这时会出现一个僵尸进程，但是马上这个僵尸进程就消失了。因为waitpid调用，子进程的资源的到释放了。
这时ps就只能看到一个正常的father进程了

duanjigang

另外你还可以让子进程多跑一会儿，父进程立马退出，就能看到子进程的父进程pid为1了，也就是被init进程接管了的现象，这些都能一一验证。
或者两次fork(),也就能看到对应的解释了。

duanjigang

改一改，这个也不错

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.                 int cc = fork();
    
12.                 if (cc == 0)
    
13.                 {
    
14.                                 system ("./test_prog");
    
15.                                 printf ("son die..\n");
    
16.                                 exit (0);
    
17.                 }
    
18.                 else
    
19.                 {
    
20.                                 int i = 0;
    
21.                                 for (i = 0; i < 5; i++)
    
22.                                 {
    
23.                                         printf ("father running %d\n", ++i);
    
24.                                         sleep (1);
    
25.                                 }
    
26.                                 printf ("father die..\n");
    
27.                                 exit(0);
    
28.                 }
    
29.                 }else
    
30.         {
    
31.                 int i = 0;
    
32.                        
    
33.                 int status = 0;
    
34.                 while (!waitpid(pid, &status, WNOHANG))
    
35.                 {
    
36.                         printf ("father waiting%d\n", ++i);
    
37.                         sleep (1);
    
38.                 }
    
39.                 //wait(NULL);
    
40.                 while (1)
    
41.                 {
    
42.                         printf ("gradpa waiting over%d\n", ++i);
    
43.                         sleep (1);
    
44.                 }
    
45.                 return 0;
    
46.         }
    
47. 
    
48. }
    
49. 
    

复制代码

duanjigang

回复  duanjigang


    谢谢你详细的例子

   可能是我没说清楚， 或者没有把重点突出出来，

   ...
morris2600 发表于 2010-07-23 10:36

    喔，呵呵，那就看看你的system执行的程序了，理解又偏差了{:3_183:}