Understanding Processes and Threads: Definitions, Differences, Advantages, and Practical Usage

Readers who study operating‑system development often encounter the terms “process” and “thread” but may not fully understand them.

Process: the smallest unit of resource allocation.

Thread: the smallest unit of program execution.

1. Process

A process is an instance of a program in execution, a collection of data structures representing the program’s state. From the kernel’s perspective, a process is the basic unit for allocating system resources such as CPU time and memory.

Example: Imagine a computer scientist (the CPU) following a cake‑baking recipe (the program) with ingredients (input data). The whole activity of reading the recipe, gathering ingredients, and baking the cake represents a process. If an urgent event occurs (e.g., a bee sting), the scientist records the current step, handles the emergency (a higher‑priority process), and then resumes the cake‑baking process.

2. Thread

A thread is the smallest unit that the CPU can schedule; it lives inside a process and shares the process’s resources. Each thread has its own ID, program counter, registers, and stack, but it does not own resources independently.

Threads can be in three states: ready (eligible to run), running (currently using the CPU), and blocked (waiting for an event such as a semaphore).

Example: A text editor that simultaneously accepts keyboard input, displays content, and writes to disk would need separate threads for each task; otherwise a single‑threaded design would block one operation while another is performed.

Summary: Processes have independent address spaces; threads share the address space of their parent process.

3. Multi‑process

A process is a dynamic execution of a program; processes can be system processes (part of the OS) or user processes (started by users). Modern OSes are multitasking, allowing many processes to run concurrently.

Concurrency is achieved via time‑slice scheduling: the OS rapidly switches the CPU among processes, giving the illusion of simultaneous execution. True parallelism occurs when multiple CPUs run different processes at the same time.

4. Multi‑thread

Multiple threads within a single process can execute concurrently, improving efficiency. An analogy: multi‑process is like a multi‑level highway system (expensive but no traffic jams), while multi‑thread is like a flat road network (cheaper but prone to traffic lights).

5. Relationship between Threads and Processes

A thread belongs to exactly one process; a process can contain many threads (at least one).

Resources are allocated to the process; all its threads share those resources.

Threads synchronize via inter‑thread communication; threads in different processes must use inter‑process communication.

The CPU actually runs threads.

A thread is an executable unit of a process.

6. Differences between Threads and Processes

Threads share memory; processes have separate memory spaces.

Threads can communicate directly; processes need a mediator.

Creating a new process is more heavyweight than creating a new thread.

Threads can control other threads in the same process; processes can only control child processes.

Changing a thread’s priority may affect other threads; changing a parent process does not affect its children.

Scheduling: threads are the basic unit for CPU scheduling; processes are the basic unit for resource ownership.

Concurrency: both can execute concurrently, but only processes provide isolation.

Resource ownership: processes own resources; threads access the resources of their parent process.

System overhead: creating/destroying processes incurs higher overhead than threads, but processes are more robust because a thread crash can terminate the whole process.

7. Advantages and Disadvantages of Processes

Advantages: closed and reproducible execution; enables concurrent execution and resource sharing, improving system efficiency.

Disadvantages: context switching is slower than thread switching; processes cannot share memory directly, making communication more complex.

8. Advantages and Disadvantages of Threads

Advantages: lightweight multitasking; shared address space reduces memory usage and context‑switch cost; easier inter‑thread communication; better utilization of multi‑CPU systems; improves program structure.

Disadvantages: frequent scheduling incurs CPU time; programming is error‑prone due to synchronization issues.

9. Advantages and Disadvantages of Multi‑threading

Advantages: no cross‑process boundaries, simple control flow, direct memory sharing, lower overall resource consumption.

Disadvantages: limited by address‑space size (typically 2 GB), synchronization and locking are complex, a single thread crash can bring down the whole process, scalability limits (e.g., ~1500 threads on Windows Server 2003).

10. Advantages and Disadvantages of Multi‑process

Advantages: isolation (a crash in one process does not affect others), easy scaling by adding CPUs, avoids thread‑locking overhead, each process gets its own address space.

Disadvantages: more complex logic, inter‑process communication overhead, not suitable for large data transfers.

In practice, the best solution often combines processes and threads: use a process per CPU and multiple threads inside each process, or choose the approach you are most comfortable with.

11. Multi‑tasking (Multi‑process) Overview

Modern operating systems (macOS, UNIX, Linux, Windows) support multitasking, allowing several tasks to run simultaneously. On a single‑core CPU, the OS interleaves tasks by rapidly switching between them; on multi‑core CPUs, true parallel execution is possible.

Each running program is a process; a process may contain multiple threads to perform several activities concurrently (e.g., a word processor handling typing, spell‑checking, and printing).

Address: https://blog.csdn.net/zaishuiyifangxym/article/details/89415155

Related reading: Traditional Architect to AI Architect Transition