Understanding Linux Processes, Threads, and Zombie Processes: A Deep Dive

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.

Process Control Block (PCB)

Each Linux process is allocated a data structure called a Process Control Block, which stores essential information such as the unique process identifier (PID). On the common i386 architecture, PIDs range from 0 to 32767, serving as the process’s identity.

Zombie Processes

A zombie process is one that has terminated but has not yet been removed from the process table. Although zombies do not consume memory or CPU resources, an excess can fill the process table and cause system instability.

Causes of Zombie Processes

When a child process exits, it retains an entry in the process table containing its exit status until the parent reads this information via wait or waitpid. If the parent does not handle the SIGCHLD signal or call these functions, the child remains a zombie. If the parent terminates, the init process adopts and cleans up the zombie.

How to Avoid Zombies

Have the parent call wait or waitpid to reap children.

Install a SIGCHLD handler that invokes wait when a child exits.

Ignore SIGCHLD (using SIG_IGN) if the parent does not need the child's exit status; the kernel will automatically reap the child.

Double‑fork: the intermediate child exits, allowing the grandchild to be adopted by init, which will clean it up.

Process vs. Thread

Processes are independent execution units with separate address spaces, while threads share the same address space within a process. A process must contain at least one thread to execute code; multiple threads can run concurrently, each with its own registers and stack.

Thread Creation and Scheduling

The first thread of a process is the primary thread, created automatically by the system. Additional threads are spawned by the primary thread. The operating system allocates CPU time slices to each thread, creating the illusion of parallel execution on a single‑CPU system.

Thread Issues and Best Practices

Multithreading offers flexibility but can introduce new problems, such as data races when multiple threads access shared resources. Proper synchronization (e.g., critical sections, mutexes, semaphores, events) and careful design—using worker threads for background work and UI threads for user interaction—are essential.

Thread Classification

In MFC, threads are categorized as worker threads (background computation without UI) and user‑interface threads (which include a message loop for handling UI events).

Thread Priority

Threads have a base priority (0–31) combined with the process’s priority. The scheduler gives CPU time to the highest‑priority runnable threads, dynamically adjusting priorities to maintain system responsiveness.

Thread Synchronization

Synchronization mechanisms—critical sections, mutexes, semaphores, and events—prevent concurrent threads from corrupting shared data. Critical sections are simple but only work within the same process; other techniques include linearization, where all writes to a data structure occur in a single thread.

Summary

Threads are lighter‑weight execution units that share a process’s address space, offering faster creation and communication than processes, which have separate address spaces and stronger isolation. Choosing between processes and threads depends on resource usage, performance, and synchronization requirements.