Why zombie processes exist?

Question

Wikipedia says "A child process that terminates but is never waited on by its parent becomes a zombie process." I run this program:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t pid, ppid;
    printf("Hello World1\n");
    pid=fork();
    if(pid==0)
    {
        exit(0);    
    }
    else
    {
        while(1)
        {
        printf("I am the parent\n");
        printf("The PID of parent is %d\n",getpid());
        printf("The PID of parent of parent is %d\n",getppid());        
        sleep(2);
        }
    }
}

This creates a zombie process, but I can't understand why a zombie process is created here?

The output of the program is

Hello World1
I am the parent
The PID of parent is 3267
The PID of parent of parent is 2456
I am the parent
The PID of parent is 3267
The PID of parent of parent is 2456
I am the parent
....
.....

But why is it that the "child process terminates but is not waited on by its parent" in this case?

Solution

In your code, zombie is created on exit(0) (comment with arrow below):

pid=fork();
if (pid==0) {
    exit(0);  // <--- zombie is created on here
} else {
    // some parent code ...
}

Why? Because you never waited on it. When something calls waitpid(pid), it returns postmortem information about process, like its exit code. Unfortunately, when process exited, kernel cannot just dispose of this process entry, or return code will be lost. So it waits for somebody to wait on it, and leaves this process entry around even if it does not really occupy any memory except for entry in process table - this is exactly what is called zombie.

You have few options to avoid creating zombies:

1. Add waitpid() somewhere in the parent process. For example, doing this will help:

   pid=fork();
   if (pid==0) {
       exit(0);    
   } else {
       waitpid(pid);  // <--- this call reaps zombie
       // some parent code ...
   }
   

2. Perform double fork() to obtain grandchild and exit in child while grandchild is still alive. Grandchildren will be automatically adopted by init if their parent (our child) dies, which means if grandchild dies, it will be automatically waited on by init. In other words, you need to do something like this:

   pid=fork();
   if (pid==0) {
       // child
       if (fork()==0) {
           // grandchild
           sleep(1); // sleep a bit to let child die first
           exit(0);  // grandchild exits, no zombie (adopted by init)
       }
       exit(0);      // child dies first
   } else {
        waitpid(pid);  // still need to wait on child to avoid it zombified
        // some parent code ...
   }
   

3. Explicitly ignore SIGCHLD signal in parent. When child dies, parent gets sent SIGCHLD signal which lets it react on children death. You can call waitpid() upon receiving this signal, or you can install explicit ignore signal handler (using signal() or sigaction()), which will make sure that child does not become zombie. In other words, something like this:

   signal(SIGCHLD, SIG_IGN); // <-- ignore child fate, don't let it become zombie
   pid=fork();
   if (pid==0) {
       exit(0); // <--- zombie should NOT be created here
   } else {
        // some parent code ...
   }