Why Do Processes Crash? A Complete Guide to Process Lifecycle and Management

Process Overview

A process is a single execution of a program that serves as an independent unit for resource allocation and scheduling. It consists of a program segment, a data segment, and a Process Control Block (PCB) that stores the execution state and control information.

Process States and Transitions

Creation : The PCB is allocated and initialized; the process becomes schedulable.

Ready : All required resources except the CPU are assigned.

Running : The process has obtained the CPU and its instructions are executing.

Blocked / Suspended : The process cannot continue because it is waiting for an event such as I/O, a synchronization primitive, or new data.

Terminated : Execution finishes, the PCB is cleared and resources are returned to the system.

Process Control Block (PCB)

Process identifiers (PID, parent PID, name)

CPU state (general‑purpose registers, instruction counter, program status word, stack pointer)

Scheduling information (current state, priority, wait time, accumulated CPU time)

Control data (memory addresses of code and data, pointers to synchronization primitives, message‑queue identifiers)

Process Creation and Termination

Creation

Request a blank PCB and a unique PID from the operating system.

Allocate required resources (memory, file descriptors, etc.).

Initialize PCB fields: identification information, initial state (ready), and resource pointers.

Insert the process into the ready queue for scheduling.

Termination

Read the process’s current state from its PCB.

Stop execution and reset scheduling flags.

Recursively terminate any child processes to avoid zombie processes.

Release all allocated resources back to the system.

Remove the PCB from the system’s PCB table.

Blocking and Activation

Blocking occurs when a process cannot proceed (e.g., waiting for I/O, a lock, or new data). Activation (resume) is performed by a suspend or active primitive, which moves the PCB back to the ready queue and restores the saved CPU context.

Process Synchronization

Synchronization ensures that multiple processes coordinate their execution order to safely share resources. The critical section is the code that accesses a shared resource; only one process may be inside it at a time.

Mutual exclusion : Only one process can hold the lock for a critical resource.

Busy‑wait : Processes spin while the resource is occupied.

Finite waiting : A process must eventually obtain the resource.

Yield‑while‑waiting : A blocked process releases the CPU instead of busy‑waiting.

Locks and Deadlock

A lock grants exclusive access to a critical resource. Deadlock occurs when two or more processes each hold a resource and wait for another held by a peer, forming a circular wait.

One common solution is to use an AND‑type semaphore (atomic allocation). The operating system attempts to allocate all required resources in a single atomic step; if any resource cannot be granted, none are allocated, preventing circular wait.

Interprocess Communication (IPC)

Typical IPC mechanisms include:

Unnamed pipes : Half‑duplex, one‑way communication between parent and child processes.

Named pipes : Half‑duplex but allow communication between unrelated processes.

Message queues : Kernel‑managed linked lists of messages identified by a queue ID.

Semaphores : Counters that control access to shared memory, acting as locks.

Signals : Asynchronous notifications of events.

Shared memory : Memory segment mapped into multiple processes’ address spaces.

Sockets : Enable communication between processes on different machines.