Understanding Processes and Threads: Definitions, Differences, and Practical Comparisons

Many readers studying operating‑system development have heard the terms "process" and "thread" but often do 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; it aggregates the data structures that represent 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 baking a birthday cake for his daughter. The recipe is the program, the scientist is the CPU, and the ingredients are the input data. The act of reading the recipe, gathering ingredients, and baking the cake represents a process.

When an urgent task (e.g., treating a bee sting) interrupts the cake‑baking, the scientist saves the current state of the process, handles the high‑priority task, and then resumes the cake‑baking from where it left off.

2. Thread – A thread is the smallest unit that the CPU schedules. It exists within a process and shares the process’s resources. A thread has its own ID, program counter, register set, and stack, but it does not own system resources independently.

Threads can be in three states: ready (eligible to run), running (currently executing), and blocked (waiting for an event such as a semaphore). Every program has at least one thread; if it has only one, the program itself is that thread.

Example: A text editor needs to accept keyboard input, display characters, and save files. If only one process handled all three tasks, they would block each other. By using separate threads for input, display, and saving, the tasks can proceed concurrently while sharing the same memory.

3. Multi‑process – Running multiple processes simultaneously is called multitasking. Processes can be system processes (part of the OS) or user processes (started by users). Modern OSes are multitasking systems that manage many processes at once.

Time‑slice (round‑robin) scheduling gives each process a short CPU burst (e.g., 10 ms), creating the illusion that all processes run simultaneously. On multi‑core CPUs, true parallelism is possible when different processes run on different cores.

4. Multi‑thread – Multiple threads within a single process allow concurrent execution of different tasks, 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 many 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 within the same process synchronize directly; threads in different processes must use inter‑process communication.

The CPU actually executes threads.

A thread is an executable unit of a process.

6. Differences

Threads share memory; processes have separate address spaces.

Threads can communicate directly; processes need a mediator.

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

Threads can affect each other’s scheduling; processes are isolated.

Changing a thread’s priority may impact other threads; changing a process’s priority does not affect others.

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

Both can execute concurrently, but processes incur higher overhead.

7. Advantages and disadvantages of processes

Advantages: clear resource boundaries, reproducibility, and ability to run multiple programs concurrently.

Disadvantages: higher creation/termination overhead and lack of shared memory.

8. Advantages and disadvantages of threads

Advantages: low overhead, easy data sharing, better CPU utilization on multi‑core systems, and improved program structure.

Disadvantages: scheduling overhead, complex synchronization, and potential for one thread’s failure to crash the whole process.

9. When to use threads vs. processes

Frequent creation/destruction → prefer threads (e.g., web server connections).

Heavy CPU‑bound computation → threads are efficient.

Strongly related tasks → threads; loosely related tasks → separate processes.

Scenarios requiring distribution across multiple machines → processes; within a single multi‑core machine → threads.

If both satisfy requirements, choose the one you are most comfortable with.

10. Multitasking (multi‑process) in modern OSes – Operating systems like macOS, Linux, and Windows support multitasking, allowing several tasks (processes) to run concurrently. Even on a single‑core CPU, the OS rapidly switches between tasks to give the illusion of simultaneous execution. True parallelism occurs on multi‑core CPUs.

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

For further reading, see the recommended links at the end of the original article.