The entire world of applications revolves around scaling and performance speed — but where does it all begin?
It all starts right here — with processes and threads.
To understand a process, we first need to go one step back and look at what a program actually is.
Program
A computer isn’t human — it can’t think or decide on its own. We have to give it clear instructions to perform any task.
These sets of instructions are what we call a program.
But how do we give these instructions? In what form? And how does the machine actually run them?
From code to CPU , below picture shows how your program comes alive.
Now that our program is running, let’s talk about what it has become — a process.
Process:
A process is simply a program in execution.
It’s not just the code anymore — it’s the code + the resources the operating system gives it to run.
When a process starts, the OS sets up everything it needs:
- Memory space – where it stores variables, data, and instructions.
- CPU time – the processor cycles it gets to actually run.
- File handles and I/O – to read files, print output, or talk to the network.
- Process ID (PID) – a unique number so the OS can track it. Every process lives inside its own isolated environment — it can’t directly access another process’s memory.
Okay, so my process is running and it has a bunch of instructions to execute.Should I wait for them to run one by one… or can I somehow speed things up?
That’s where threads come in.
Thread:
A thread is the smallest unit of execution inside a process — like a lightweight worker that helps your program do multiple things at the same time.
A thread is “lightweight” because it takes less memory, less setup, and less time for the OS to manage compared to a process.
When a program starts, it begins with one thread, the main thread.
From there, you can create additional threads to perform other tasks simultaneously.
Each thread has:
- Its own stack (to keep track of function calls and local variables)
- Its own instruction pointer (to know which line of code it’s running)
- Shared access to the process’s memory (heap, global variables, files, etc.)
Process vs Thread
| Aspect | Process | Thread |
|---|---|---|
| Definition | A program in execution. | A lightweight unit of execution inside a process. |
| Memory Space | Has its own memory space — fully isolated. | Shares memory with other threads in the same process. |
| Creation Cost | High — needs new memory and OS resources. | Low — shares process resources; only needs its own stack/registers. |
| Communication | Via Inter-Process Communication (IPC) — slower. | Via shared memory — faster but needs synchronization. |
| Crash Impact | One process crashing doesn’t affect others. | If one thread crashes, it can crash the entire process. |
| Context Switching | Slower — switches entire process context. | Faster — switches only registers and stack. |
| Isolation | Strong isolation — safer, but uses more memory. | Weak isolation — faster, but risk of race conditions. |
| Use Case | Running independent apps or services. | Running parallel tasks within the same app. |
| Scaling Approach | Horizontal scaling — multiple processes across CPU cores, containers, or machines for reliability and load balancing. | Vertical scaling — multiple threads inside one process to use CPU cores efficiently for concurrent tasks. |
| Performance | More reliable under load; startup is heavier. | Higher throughput for shared-memory tasks; needs careful synchronization. |
| Examples | Chrome launching each tab as a separate process; microservices architecture. | Each Chrome tab’s renderer thread; thread pools in Java or Node.js workers. |
Restaurant Analogy:
Imagine your computer as a restaurant.
The recipe is your program — a set of written instructions waiting to be cooked.
Once the cooking begins, it becomes a process — an active kitchen with its own space, tools, and ingredients.
Inside that kitchen, several chefs (threads) work together on different parts of the dish — one boils pasta, another stirs sauce — all sharing the same kitchen.
That’s how each process can have multiple threads, working in parallel to serve the dish faster.
Top comments (0)