Linux僵尸进程的概念、 产生的原因以及如何避免产生僵尸进程
2013-09-23 13:39:36
转自：http://blog.csdn.net/wry323/article/details/5485910
一、定义：什么是孤儿进程和僵尸进程
僵尸进程：一个子进程在其父进程还没有调用wait()或waitpid()的情况下退出。这个子进程就是僵尸进程。
孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
僵尸进程将会导致资源浪费，而孤儿则不会。
示例:
子进程持续10秒钟的僵尸状态(EXIT_ZOMBIE)
------------------------------------------------------
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
main()
{
pid_t pid;
pid = fork();
if(pid < 0)
printf("error occurred!/n");
else if(pid == 0) {
printf("Hi father! I'm a ZOMBIE/n");
exit(0); //(1)
}
else {
sleep(10);
wait(NULL); //(2)
}
}
(1) 向父进程发送SIGCHILD信号
(2) 父进程处理SIGCHILD信号
执行exit()时根据其父进程的状态决定自己的状态:
如果父进程已经退出(没有wait)，则该子进程将会成为孤儿进程过继给init进程
如果其父进程还没有退出，也没有wait()，那么该进程将向父进程发送SIGCHILD信号，进入僵尸状态等待父进程为其收尸。如果父进程一直没有执行wait()，那么该子进程将会持续处于僵尸状态。
子进程将成为孤儿进程
------------------------------------------------------
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
main()
{
pid_t pid;
pid = fork();
if(pid < 0)
printf("error occurred!/n");
else if(pid == 0) {
sleep(6);
printf("I'm a orphan/n");
exit(0);
}
else {
sleep(1);
printf("Children Bye!/n");
}
}
# ./a.out
Children Bye!
# I'm a orphan
(回车后将会进入#)
#
二、有什么害处：
僵尸进程会占用系统资源，如果很多，则会严重影响服务器的性能
孤儿进程不会占用系统资源
处理流程:
只要老爹不等wait(sys/wait.h)儿子,儿子都将成为孤魂野鬼zombie(zombie),unix中默认老爹总是想看儿子死后的状态(以便报仇)
if 老爹比儿子先再见
儿子将被init(id = 1)收养,最后的结果是zombie儿子彻底再见,系统资源释放
else
{
儿子的zombie将一直存在,系统资源占用...
if 老爹dead
儿子将被init(id = 1)收养,最后的结果是zombie儿子彻底再见,系统资源释放
else 类似的儿子zombie越来越多,系统就等死了!!!
}
三、如何防止僵尸进程
首先明白如何产生僵尸进程：
1、子进程结束后向父进程发出SIGCHLD信号，父进程默认忽略了它
2、父进程没有调用wait()或waitpid()函数来等待子进程的结束
第一种方法: 捕捉SIGCHLD信号,并在信号处理函数里面调用wait函数
转贴Richard Steven的Unix Network Programming代码
int
main(int argc, char **argv)
{
...
Signal(SIGCHLD, sig_chld);
for(;
}
...
}
void
sig_chld(int signo)
{
pid_t pid;
int stat;
while ( (pid = waitpid(-1, &stat, WNOHANG)) >; 0)
printf("child %d terminated/n", pid);
return;
}
第二种方法：两次fork()：转载
在《Unix 环境高级编程》里关于这个在8.6节有非常清楚的说明。
实例
回忆一下8 . 5节中有关僵死进程的讨论。如果一个进程要f o r k一个子进程，但不要求它等待
子进程终止，也不希望子进程处于僵死状态直到父进程终止，实现这一要求的诀窍是调用f o r k
两次。程序8 - 5实现了这一点。
在第二个子进程中调用s l e e p以保证在打印父进程I D时第一个子进程已终止。在f o r k之后，
父、子进程都可继续执行——我们无法预知哪一个会先执行。如果不使第二个子进程睡眠，则
在f o r k之后，它可能比其父进程先执行，于是它打印的父进程I D将是创建它的父进程，而不是
i n i t进程（进程ID 1）。
#include <sys/types.h>
#include <sys/wait.h>
#include "ourhdr.h"
int
main(void)
{
pid_t pid;
if ( (pid = fork()) < 0)
err_sys("fork error");
else if (pid == 0) { /* first child */
if ( (pid = fork()) < 0)
err_sys("fork error");
else if (pid > 0)
exit(0); /* parent from second fork == first child */
/* We're the second child; our parent becomes init as soon
as our real parent calls exit() in the statement above.
Here's where we'd continue executing, knowing that when
we're done, init will reap our status. */
sleep(2);
printf("second child, parent pid = %d/n", getppid());
exit(0);
}
if (waitpid(pid, NULL, 0) != pid) /* wait for first child */
err_sys("waitpid error");
/* We're the parent (the original process); we continue executing,
knowing that we're not the parent of the second child. */
exit(0);
}
//avoid zombie process by forking twice
下面转自：http://blog.csdn.net/fengwei321123/article/details/9301409
给进程设置僵尸状态的目的是维护子进程的信息，以便父进程在以后某个时间获取。这些信息包括子进程的进程ID、终止状态以及资源利用信息(CPU时间，内存使用量等等)。如果一个进程终止，而该进程有子进程处于僵尸状态，那么它的所有僵尸子进程的父进程ID将被重置为1（init进程）。继承这些子进程的init进程将清理它们(init进程将wait它们，从而去除僵尸状态)。
但通常情况下，我们是不愿意留存僵尸进程的，它们占用内核中的空间，最终可能导致我们耗尽进程资源。那么为什么会产生僵尸进程以及如何避免产生僵尸进程呢？下边我将从这两个方面进行分析。
僵尸进程的原因
我们知道，要在当前进程中生成一个子进程，一般需要调用fork这个系统调用，fork这个函数的特别之处在于一次调用，两次返回，一次返回到父进程中，一次返回到子进程中，我们可以通过返回值来判断其返回点：
pid_t child = fork();
if( child < 0 ) { //fork error.
perror("fork process fail.\n");
} else if( child ==0 ) { // in child process
printf(" fork succ, this run in child process\n ");
} else { // in parent process
printf(" this run in parent process\n ");
}
如果子进程先于父进程退出， 同时父进程又没有调用wait/waitpid，则该子进程将成为僵尸进程。通过ps命令，我们可以看到该进程的状态为Z(表示僵死)，如图1所示：
(图1)
备注: 有些unix系统在ps命令输出的COMMAND栏以<defunct>指明僵尸进程。
代码如下：
if( child == -1 ) { //error
perror("\nfork child error.");
exit(0);
} else if(child == 0){
cout << "\nIm in child process:" << getpid() << endl;
exit(0);
} else {
cout << "\nIm in parent process." << endl;
sleep(600);
}
让父进程休眠600s, 然后子进程先退出，我们就可以看到先退出的子进程成为僵尸进程了（进程状态为Z）
避免产生僵尸进程
我们知道了僵尸进程产生的原因，下边我们看看如何避免产生僵尸进程。
一般，为了防止产生僵尸进程，在fork子进程之后我们都要wait它们；同时，当子进程退出的时候，内核都会给父进程一个SIGCHLD信号，所以我们可以建立一个捕获SIGCHLD信号的信号处理函数，在函数体中调用wait（或waitpid），就可以清理退出的子进程以达到防止僵尸进程的目的。如下代码所示：
void sig_chld( int signo ) {
pid_t pid;
int stat;
pid = wait(&stat);
printf( "child %d exit\n", pid );
return;
}
int main() {
signal(SIGCHLD, &sig_chld);
}
现在main函数中给SIGCHLD信号注册一个信号处理函数（sig_chld），然后在子进程退出的时候，内核递交一个SIGCHLD的时候就会被主进程捕获而进入信号处理函数sig_chld，然后再在sig_chld中调用wait，就可以清理退出的子进程。这样退出的子进程就不会成为僵尸进程。
然后，即便我们捕获SIGCHLD信号并且调用wait来清理退出的进程，仍然不能彻底避免产生僵尸进程；我们来看一种特殊的情况：
我们假设有一个client/server的程序，对于每一个连接过来的client，server都启动一个新的进程去处理来自这个client的请求。然后我们有一个client进程，在这个进程内，发起了多个到server的请求（假设5个），则server会fork 5个子进程来读取client输入并处理（同时，当客户端关闭套接字的时候，每个子进程都退出）；当我们终止这个client进程的时候 ，内核将自动关闭所有由这个client进程打开的套接字，那么由这个client进程发起的5个连接基本在同一时刻终止。这就引发了5个FIN，每个连接一个。server端接受到这5个FIN的时候，5个子进程基本在同一时刻终止。这就又导致差不多在同一时刻递交5个SIGCHLD信号给父进程，如图2所示：
（图2）
正是这种同一信号多个实例的递交造成了我们即将查看的问题。
我们首先运行服务器程序，然后运行客户端程序，运用ps命令看以看到服务器fork了5个子进程，如图3：
（图3）
然后我们Ctrl+C终止客户端进程，在我机器上边测试，可以看到信号处理函数运行了3次，还剩下2个僵尸进程，如图4：
（图4）
通过上边这个实验我们可以看出，建立信号处理函数并在其中调用wait并不足以防止出现僵尸进程，其原因在于：所有5个信号都在信号处理函数执行之前产生，而信号处理函数只执行一次，因为Unix信号一般是不排队的(我的这篇博客中有提到http://www.cnblogs.com/yuxingfirst/p/3160697.html)。 更为严重的是，本问题是不确定的，依赖于客户FIN到达服务器主机的时机，信号处理函数执行的次数并不确定。
正确的解决办法是调用waitpid而不是wait，这个办法的方法为：信号处理函数中，在一个循环内调用waitpid，以获取所有已终止子进程的状态。我们必须指定WNOHANG选项，他告知waitpid在有尚未终止的子进程在运行时不要阻塞。（我们不能在循环内调用wait，因为没有办法防止wait在尚有未终止的子进程在运行时阻塞，wait将会阻塞到现有的子进程中第一个终止为止），下边的程序分别给出了这两种处理办法(func_wait, func_waitpid)。
//server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <errno.h>
#include <error.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
typedef void sigfunc(int);
void func_wait(int signo) {
pid_t pid;
int stat;
pid = wait(&stat);
printf( "child %d exit\n", pid );
return;
}
void func_waitpid(int signo) {
pid_t pid;
int stat;
while( (pid = waitpid(-1, &stat, WNOHANG)) > 0 ) {
printf( "child %d exit\n", pid );
}
return;
}
sigfunc* signal( int signo, sigfunc *func ) {
struct sigaction act, oact;
act.sa_handler = func;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if ( signo == SIGALRM ) {
#ifdef SA_INTERRUPT
act.sa_flags |= SA_INTERRUPT; /* SunOS 4.x */
#endif
} else {
#ifdef SA_RESTART
act.sa_flags |= SA_RESTART; /* SVR4, 4.4BSD */
#endif
}
if ( sigaction(signo, &act, &oact) < 0 ) {
return SIG_ERR;
}
return oact.sa_handler;
}
void str_echo( int cfd ) {
ssize_t n;
char buf[1024];
again:
memset(buf, 0, sizeof(buf));
while( (n = read(cfd, buf, 1024)) > 0 ) {
write(cfd, buf, n);
}
if( n <0 && errno == EINTR ) {
goto again;
} else {
printf("str_echo: read error\n");
}
}
int main() {
signal(SIGCHLD, &func_waitpid);
int s, c;
pid_t child;
if( (s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
int e = errno;
perror("create socket fail.\n");
exit(0);
}
struct sockaddr_in server_addr, child_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(9998);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if( bind(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0 ) {
int e = errno;
perror("bind address fail.\n");
exit(0);
}
if( listen(s, 1024) < 0 ) {
int e = errno;
perror("listen fail.\n");
exit(0);
}
while(1) {
socklen_t chilen = sizeof(child_addr);
if ( (c = accept(s, (struct sockaddr *)&child_addr, &chilen)) < 0 ) {
perror("listen fail.");
exit(0);
}
if( (child = fork()) == 0 ) {
close(s);
str_echo(c);
exit(0);
}
close(c);
}
}
//client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <errno.h>
#include <error.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>
void str_cli(FILE *fp, int sfd ) {
char sendline[1024], recvline[2014];
memset(recvline, 0, sizeof(sendline));
memset(sendline, 0, sizeof(recvline));
while( fgets(sendline, 1024, fp) != NULL ) {
write(sfd, sendline, strlen(sendline));
if( read(sfd, recvline, 1024) == 0 ) {
printf("server term prematurely.\n");
}
fputs(recvline, stdout);
memset(recvline, 0, sizeof(sendline));
memset(sendline, 0, sizeof(recvline));
}
}
int main() {
int s[5];
for (int i=0; i<5; i++) {
if( (s[i] = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
int e = errno;
perror("create socket fail.\n");
exit(0);
}
}
for (int i=0; i<5; i++) {
struct sockaddr_in server_addr, child_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(9998);
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
if( connect(s[i], (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0 ) {
perror("connect fail.");
exit(0);
}
}
sleep(10);
str_cli(stdin, s[0]);
exit(0);
}
浙公网安备 33010602011771号