Why Do Zombie Processes Appear in Linux and How to Prevent Them?

When a program starts executing, the portion of it that resides in memory until it finishes is called a process.

Linux is a multitasking operating system, meaning multiple processes can run concurrently; on a single‑CPU machine each time slice executes only one instruction.

Linux achieves apparent simultaneous execution through process scheduling: each process receives a short time slice (typically milliseconds), the scheduler selects a process to run, and when its slice expires, finishes, or is paused, another process is chosen, giving the illusion of parallelism.

Each Linux process is assigned a Process Control Block (PCB) containing essential information such as the unique process identifier (PID), which on i386 ranges from 0 to 32767.

Zombie Process Generation

A zombie process is one that has terminated but has not yet been removed from the process table; it occupies no resources but can fill the table and cause system instability.

In the zombie state the process has released almost all memory and code, retaining only an entry with its exit status for the parent to collect; if the parent does not handle SIGCHLD and call

wait

or

waitpid

, the zombie persists until the init process adopts and reaps it.

Causes of Zombie Processes

When a process forks, the kernel creates a new entry in the process table with a parent PID. After the child calls

exit()

, its exit code and resource usage remain in the table until the parent reads them; if the parent does not read them before the child exits, a zombie results.

How to Avoid Zombie Processes

1. Have the parent call

wait

or

waitpid

to reap children (may block the parent).

2. Install a SIGCHLD handler using

signal

so the parent can reap the child when notified.

3. If the parent does not care about the child’s termination, ignore SIGCHLD (e.g.,

signal(SIGCHLD, SIG_IGN)

) so the kernel reaps the child automatically.

4. Use a double‑fork technique: the parent forks a child, which immediately forks a grandchild and exits; the grandchild is adopted by init, which will reap it.

Process vs. Thread

Think of threads as a flat traffic system with many lights (low cost but can get congested), while processes are like overpasses (higher cost but less contention). A process is an instance of a program with its own address space; it must contain at least one thread that executes code within that space.

A process may contain multiple threads, each with its own CPU registers and stack, allowing concurrent execution of code in the same address space.

Multithreading Implementation

The first thread created with a process is the primary thread, generated automatically by the system; additional threads can be spawned from it. The OS schedules each thread using time slices, creating the illusion of simultaneous execution.

Multithreading Issues

While multithreading offers flexibility, improper design can introduce new problems, such as data races when a document is printed in a separate thread while the user edits it. Solutions include locking the document during printing or printing a temporary copy.

Thread Classification

In MFC, threads are classified as worker threads (background computation without UI) and UI threads (handle user interface and have a message loop).

Thread Priority

Threads have a base priority (0–31). The scheduler gives CPU time first to the highest‑priority threads; priorities can be changed by programs or dynamically by the OS in response to events.

Thread Synchronization

To avoid data corruption, threads must synchronize using mechanisms such as critical sections, mutexes, semaphores, and events. Critical sections are simple but only work within the same process; a linearization approach (performing all writes in a single thread) also ensures safety.

Summary

Threads are lighter‑weight execution units that share a process’s address space, while processes have separate address spaces; threads provide faster creation, communication, and context switching, whereas processes offer stronger isolation and resource management.