Why Zombie Processes Occur in Linux and How Multithreading Works

Process Basics

When a program starts executing, the portion of memory it occupies during its lifetime is called a process. Linux, as a multitasking operating system, can run multiple processes concurrently by assigning each a short time slice (typically milliseconds) and scheduling them in turn, giving the illusion of simultaneous execution.

Each Linux process is represented by a Process Control Block (PCB) that stores essential information, most notably the unique process identifier (PID), which on i386 ranges from 0 to 32767.

Zombie Process Generation

A zombie process is a terminated process that remains in the process table because its exit status has not yet been collected. Although zombies do not consume memory or CPU resources, an excess can fill the process table and cause system instability.

When a child process calls exit(), the kernel retains a minimal entry containing its exit status. The parent must read this information via wait() or waitpid(), or install a handler for the SIGCHLD signal. If the parent ignores the signal and does not wait, the child stays as a zombie. If the parent exits, the init process adopts the child and reaps it.

Causes of Zombie Processes

After a fork(), the kernel creates a new entry in the process table, recording the parent’s PID. When the child finishes and calls exit(), its entry persists until the parent reads the exit information. Thus, zombies appear when the parent has not yet retrieved the child’s termination data.

How to Avoid Zombie Processes

1. Have the parent call wait() or waitpid() to block until the child exits. 2. Install a SIGCHLD handler using signal() so the parent can reap the child asynchronously. 3. Ignore SIGCHLD with SIG_IGN, allowing the kernel to automatically reap the child. 4. Double‑fork: the intermediate child exits, leaving the grandchild adopted by init, which will clean it up.

Process vs. Thread

Think of processes as separate highways (high cost, no traffic jams) and threads as intersections (low cost, possible congestion). A process provides an address space; a thread is the execution unit that runs code within that space. Multiple threads share the same memory but have independent registers and stacks.

Multithreading Implementation

The first thread created with a process is the primary thread, generated by the system. Additional threads are spawned by the primary thread. The OS schedules each thread using time slices (quantum) in a round‑robin fashion, giving the illusion of parallel execution on a single‑CPU system.

Multithreading Issues

While threads increase flexibility, they can introduce new problems such as data races. For example, printing in a separate thread may conflict with concurrent edits to the same document. Solutions include locking the document during printing, or printing a temporary copy while allowing edits on the original.

Thread Classification

In MFC, threads are divided into worker threads (background computation without UI) and user‑interface threads (which have a message loop). Choose the type based on whether the thread needs to interact with the user.

Thread Priorities

Threads have a base priority (0‑31). The scheduler prefers higher‑priority threads, allocating CPU time to the highest‑priority runnable thread. The system may also dynamically adjust priorities, e.g., boosting the thread handling a key press.

Thread Synchronization

Synchronization ensures that concurrent threads do not corrupt shared data. In MFC, synchronization objects include critical sections, mutexes, semaphores, and events. Critical sections are simple but work only within a single process. An alternative is the linearization method: perform all writes to a particular data set in a single thread.

Summary

Threads are lightweight execution units that share a process’s address space, offering fast context switches and communication, while processes provide isolation and independent resources. Understanding their differences, scheduling, priorities, and synchronization mechanisms is essential for building efficient, responsive applications.