執(zhí)行system后產(chǎn)生defunct，高手進(jìn)來分析下

morris2600

程序中通過system（）調(diào)用另一個可執(zhí)行程序， 如：
if (0 != system("./exe_process args"))
{
     DEBUGLOG("error");
}

但在長期運(yùn)行中經(jīng)常發(fā)現(xiàn)出現(xiàn) exe_process 的defunct進(jìn)程， 看了下system的源碼， 無非就是fork, exec, waitpid

不明白為什么會出現(xiàn)僵尸進(jìn)程

補(bǔ)充： 此程序運(yùn)行時內(nèi)存可能有限， 不知道是否有影響

openspace

能把源碼貼一下嗎？

morris2600

源碼幾乎就是我上面貼的樣子， 就是在一個函數(shù)里調(diào)用system，沒什么特別的

yjh777

僵尸進(jìn)程產(chǎn)生的條件你知道嗎？？

morris2600

感謝關(guān)注

所謂僵尸進(jìn)程，應(yīng)該是子進(jìn)程退出了， 而父進(jìn)程并沒有處理子進(jìn)程的退出（waitpid或SIGCHLD等）， 導(dǎo)致子進(jìn)程的部分資源沒有完全銷毀而產(chǎn)生的吧

理解不對的地方還望指教

我的問題是， system的源碼里是處理了子進(jìn)程的推出的， 不明白什么情況下會產(chǎn)生僵尸

duanjigang

兩次fork執(zhí)行你的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. }
    

復(fù)制代碼

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

morris2600

感謝樓上解答

其實(shí)我的本意是想知道為什么system會產(chǎn)生僵尸進(jìn)程， 比如有人碰到過、或者能從原理上講明白

當(dāng)然如果解決不了的話可能會考慮改為fork兩次

duanjigang

感謝樓上解答

其實(shí)我的本意是想知道為什么system會產(chǎn)生僵尸進(jìn)程， 比如有人碰到過、或者能從原理上講明白 ...
morris2600 發(fā)表于 2010-07-23 08:54

首先你可以看下《linux內(nèi)核設(shè)計與實(shí)現(xiàn)》大概前幾章，有一章講這個的。另外，下面
這篇文章說的也很好。
http://hi.baidu.com/kobetec/blog ... dca883e950cdf4.html
怎樣避免產(chǎn)生僵尸進(jìn)程2008-02-20 17:09怎樣避免產(chǎn)生僵尸進(jìn)程
摘錄于: <<Advanced Programming in the UNIX&reg; Environment: Second Edition>> By W. Richard Stevens, Stephen
1.什么是僵尸進(jìn)程?
In UNIX System terminology, a process that has terminated,but whose

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

在UNIX 系統(tǒng)中,一個進(jìn)程結(jié)束了,但是他的父進(jìn)程沒有等待(調(diào)用wait / waitpid)他,

那么他將變成一個僵尸進(jìn)程.

但是如果該進(jìn)程的父進(jìn)程已經(jīng)先結(jié)束了,那么該進(jìn)程就不會變成僵尸進(jìn)程,

因?yàn)槊總�進(jìn)程結(jié)束的時候,系統(tǒng)都會掃描當(dāng)前系統(tǒng)中所運(yùn)行的所有進(jìn)程,

看有沒有哪個進(jìn)程是剛剛結(jié)束的這個進(jìn)程的子進(jìn)程,如果是的話,就由Init

來接管他,成為他的父進(jìn)程,從而保證每個進(jìn)程都會有一個父進(jìn)程.

而Init進(jìn)程會自動wait 其子進(jìn)程,因此被Init接管的所有進(jìn)程都不會變成僵尸進(jìn)程.

2. 僵尸進(jìn)程的危害
由于子進(jìn)程的結(jié)束和父進(jìn)程的運(yùn)行是一個異步過程,即父進(jìn)程永遠(yuǎn)無法預(yù)測子進(jìn)程

到底什么時候結(jié)束. 那么不會因?yàn)楦高M(jìn)程太忙來不及waid子進(jìn)程,或者說不知道

子進(jìn)程什么時候結(jié)束,而丟失子進(jìn)程結(jié)束時的狀態(tài)信息呢?

不會.因?yàn)閁NIX提供了一種機(jī)制可以保證 只要父進(jìn)程想知道子進(jìn)程結(jié)束時的狀態(tài)信息,

就可以得到. 這種機(jī)制就是:

在每個進(jìn)程退出的時候,內(nèi)核釋放該進(jìn)程所有的資源,包括打開的文件,占用的內(nèi)存等.

但是仍然為其保留一定的信息(包括進(jìn)程號the process ID,退出狀態(tài)the termination

status of the process,運(yùn)行時間the amount of CPU time taken by the process等),

直到父進(jìn)程通過wait / waitpid來取時才釋放.

但這樣就導(dǎo)致了問題,如果你進(jìn)程不調(diào)用wait / waitpid的話, 那么保留的那段信息就不會

釋放,其進(jìn)程號就會一定被占用,但是系統(tǒng)所能使用的進(jìn)程號是有限的,如果大量的產(chǎn)生

僵死進(jìn)程,將因?yàn)闆]有可用的進(jìn)程號而導(dǎo)致系統(tǒng)不能產(chǎn)生新的進(jìn)程.

此即為僵尸進(jìn)程的危害,應(yīng)當(dāng)避免.

3.僵尸進(jìn)程的避免
1、父進(jìn)程通過wait和waitpid等函數(shù)等待子進(jìn)程結(jié)束，這會導(dǎo)致父進(jìn)程掛起

2. 如果父進(jìn)程很忙，那么可以用signal函數(shù)為SIGCHLD安裝handler，因?yàn)樽舆M(jìn)程結(jié)束后，

父進(jìn)程會收到該信號，可以在handler中調(diào)用wait回收


3. 如果父進(jìn)程不關(guān)心子進(jìn)程什么時候結(jié)束，那么可以用signal（SIGCHLD, SIG_IGN）

通知內(nèi)核，自己對子進(jìn)程的結(jié)束不感興趣，那么子進(jìn)程結(jié)束后，內(nèi)核會回收，

并不再給父進(jìn)程發(fā)送信號

4. 還有一些技巧，就是fork兩次，父進(jìn)程fork一個子進(jìn)程，然后繼續(xù)工作，子進(jìn)程fork一

個孫進(jìn)程后退出，那么孫進(jìn)程被init接管，孫進(jìn)程結(jié)束后，init會回收。不過子進(jìn)程的回收

還要自己做。 下面就是Stevens給的采用兩次folk避免僵尸進(jìn)程的示例.
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. 
    

復(fù)制代碼

duanjigang

根據(jù)理論我們做個測試的例子。
子進(jìn)程要執(zhí)行的程序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. }
    

復(fù)制代碼

父進(jìn)程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. }
    

復(fù)制代碼

執(zhí)行./father,當(dāng)子進(jìn)程退出后，由于父進(jìn)程沒有對它的退出進(jìn)行關(guān)注，會出現(xiàn)僵尸進(jìn)程

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

復(fù)制代碼