The Process Lifecycle

[!NOTE] This module explores the core principles of The Process Lifecycle, deriving solutions from first principles and hardware constraints to build world-class, production-ready expertise.

Imagine opening Chrome, Slack, and your terminal all at once. Your laptop might only have 4 CPU cores, yet 150 different applications seem to run smoothly and simultaneously. How does the OS juggle all this without freezing or mixing your Slack messages with your terminal commands? The answer lies in the Process Lifecycle.

1. What is a Process?

[!TIP] Program vs Process: A Program is a passive entity (like a recipe book on a shelf). A Process is an active entity (like a chef cooking the recipe).

A process is the fundamental unit of execution in an operating system. It includes:

  • Text Section: The compiled code (instructions).
  • Program Counter (PC): A pointer to the next instruction to execute.
  • Stack: Temporary data (function parameters, return addresses, local variables).
  • Data Section: Global variables.
  • Heap: Dynamically allocated memory.

2. The Process Control Block (PCB)

The OS manages thousands of processes. How does it keep track? It uses a massive table of structures called Process Control Blocks (PCBs).

Think of the PCB as the “Passport” or “Medical Record” of a process. It resides in Kernel Memory.

Field Description
PID Process ID (Unique Integer).
State New, Ready, Running, Waiting, Terminated.
PC Program Counter (Where did we stop?).
Registers CPU registers (Accumulator, Index, Stack Pointer) saved during a context switch.
Scheduling Info Priority, pointers to scheduling queues.
Memory Info Page tables, Segment tables (Base/Limit).
I/O Info List of open files (File Descriptors), I/O devices allocated.

[!NOTE] Context Switching: When the CPU switches from Process A to Process B, it must save the PCB of A and load the PCB of B. This is pure overhead (CPU does no useful work during the switch).

3. The 5-State Process Model

A process moves through distinct states during its life.

  1. New: The process is being created. The PCB is allocated, but code isn’t loaded into RAM yet.
  2. Ready: The process is in RAM, waiting for the CPU. It sits in the Ready Queue.
  3. Running: The process has the CPU and is executing instructions.
  4. Waiting (Blocked): The process is waiting for some event (I/O completion, signal). It cannot run even if the CPU is free!
  5. Terminated: The process has finished execution. PCB is deallocated.

Interactive: Process State Manager

Control the lifecycle of a process. Watch how the PCB state updates.

New
→
Ready
↔
Running
→
Terminated
Waiting
Process Control Block (PID: 1042)
State: NEW
PC: 0x0000
CPU: Not Assigned

4. Special Processes: Zombies & Orphans

Unix systems have interesting parent-child relationships.

Zombie Process

A process that has finished execution (exit()) but has still has an entry in the process table.

  • Why? The parent hasn’t read its exit status yet using wait().
  • Analogy: A ghost waiting for its master to acknowledge its death.
  • Fix: Parent calls wait().

Orphan Process

A process whose parent has died.

  • Outcome: Adopted by init (PID 1) or systemd. init automatically waits for its children, cleaning up the mess.

[!TIP] War Story: The “Unkillable” Process

Imagine a backend service that forks workers to handle incoming web requests. If a bug causes the worker to finish but the parent service never calls wait(), the worker becomes a Zombie. Over hours, thousands of these zombies accumulate. You run kill -9 <PID> but nothing happens! Why? Because a Zombie is already dead; it only exists as an entry in the Process Table. The only way to clear it is to kill the parent service, turning the zombies into Orphans, which are then adopted by init (PID 1) and properly reaped.

5. Code Example: Creating Processes

In modern development, we rarely use raw fork()/exec(). We use higher-level abstractions.

Java

import java.io.IOException;

public class ProcessDemo {
    public static void main(String[] args) {
        // ProcessBuilder is the modern way to spawn processes
        ProcessBuilder pb = new ProcessBuilder("ls", "-l");

        try {
            // Start the process
            Process process = pb.start();

            // Wait for it to finish (like waitpid)
            int exitCode = process.waitFor();
            System.out.println("Process exited with code: " + exitCode);

        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Go

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    // Helper for exec() family syscalls
    cmd := exec.Command("ls", "-l")

    // Run() combines Start() and Wait()
    err := cmd.Run()

    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Process finished successfully.")
    }
}