Understanding Processes and Threads: Core Concepts, Lifecycle, and Scheduling

Process and Thread Concepts

Operating systems like Windows and Linux use preemptive round‑robin scheduling, where each task runs for a short time slice before being paused for the next task. The running state is called "running" and the paused state is "ready", creating the illusion of concurrent execution.

Process

A process is an independent unit of execution that the OS schedules and allocates resources to. It consists of a program, its data, and a Process Control Block (PCB) that stores descriptive and control information.

Process Characteristics:

Dynamic: a temporary execution instance with a lifespan.

Concurrent: can run alongside other processes.

Independent: the OS treats it as a separate resource‑allocation unit.

Structured: composed of program, data, and PCB.

Early OSes defined five process states: created, ready, running, blocked (waiting), and exited.

Thread

Threads are the smallest unit of program execution and the basic unit of CPU scheduling. A process may contain one or many threads, which share the process's memory space.

Standard Thread Components: thread ID, program counter (PC), registers, and stack.

Thread Lifecycle

When the number of threads is less than the number of processors, threads run truly concurrently on separate cores. Otherwise, the OS time‑slices threads, creating simulated concurrency.

Thread states mirror process states: created, ready, running, blocked, and exited.

Thread Priority

Operating systems also use priority scheduling; higher‑priority threads run before lower‑priority ones. Priorities can be set manually or adjusted by the OS based on I/O‑bound versus CPU‑bound behavior.

Priority changes occur via:

User‑specified priority.

OS‑adjusted priority based on wait frequency.

Priority boost after prolonged waiting (to prevent starvation). Thread Starvation Low‑priority threads may starve if higher‑priority threads dominate CPU time. OSes mitigate this by gradually raising the priority of waiting threads.

Multithreading and Multicore

Modern CPUs integrate multiple cores, each capable of true parallel execution. Kernel threads (KLT) are directly supported by the OS and map to physical or logical cores. Thread models:

One‑to‑One Model: each user thread maps to a unique kernel thread, providing true concurrency but limited by kernel thread count and context‑switch overhead.

Many‑to‑One Model: many user threads share a single kernel thread, offering fast switches but blocking all threads if one blocks.

Many‑to‑Many Model: multiple user threads map to multiple kernel threads, combining benefits of both models while allowing many user threads.

Differences Between Processes and Threads

Process: OS resource‑allocation unit; thread: smallest execution unit.

Threads share a process's memory and resources; processes are isolated.

Thread context switches are faster than process switches.

Synchronization Mechanisms

Mutual exclusion (mutex) ensures exclusive access to a shared resource, analogous to a single‑key lock. A semaphore generalizes this concept, allowing up to n concurrent accesses, similar to a set of keys for a room that can hold n people.

Operating System Design Goals

Support multiple processes to run simultaneously.

Support multithreading within a single process.

Provide coordination mechanisms to avoid conflicts while allowing resource sharing.

Original source: http://luckylau.tech/2017/06/20/%E8%BF%9B%E7%A8%8B%E5%92%8C%E7%BA%BF%E7%A8%8B%E7%9A%84%E5%8C%BA%E5%88%AB/ (author: Luckylau)