Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1380598
  • 博文数量: 317
  • 博客积分: 1557
  • 博客等级: 上尉
  • 技术积分: 1208
  • 用 户 组: 普通用户
  • 注册时间: 2008-02-26 23:38
个人简介

如果想出发,就不要等到明天!

文章分类

全部博文(317)

文章存档

2016年(1)

2015年(41)

2014年(152)

2013年(114)

2012年(4)

2011年(1)

2009年(4)

分类: C/C++

2015-03-24 07:32:58

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(),这种方式我个人认为是最为简洁的方式。





    
    

        



阅读(2472) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册