Thread, Processor and Worker

A thread is a unit of execution within a process, allowing tasks to run concurrently, while the processor (CPU) handles these tasks by performing computations. A worker executes specific jobs within an application, often as part of a pool, to enhance parallelism and efficiency.

What is a Program?

It’s an executable file that contains the code or a set of processor instructions, that is stored as a file on disk.

When a code is loaded into memory and executed by the processor, it becomes a process.

What is a Process?

A process is an instance of a program that is being executed.
It contains the program code, data, and its execution state (such as registers, program counter, etc.).
Processes are isolated from one another and each process has its own memory space, file descriptors, and resources.

What is a Thread?

A thread is the smallest unit of execution within a process.
While processes have their own memory space, threads share the memory of their parent process.
A process has at least one thread which is called the main thread. Commonly, a process has many threads and works concurrently.
Threads within a process share a memory address space, it’s possible to communicate between threads using that shared memory space. However, one misbehaving thread could bring down the entire process.

What is a worker?

A worker is essentially a helper, usually a thread or process, that takes on small tasks and works asynchronously on them in the background.
These tasks are often separate from the main part of the application, allowing the primary process to stay focused on more important operations, like responding to users or managing resources.

Note

A worker is usually either a thread or a process, depending on how the system is set up.

In some systems, a worker is just a thread within a process, which means it shares memory and resources with other threads in the same process.
In other systems, a worker might be a separate process, which has its own memory space and runs independently.

In both cases, the term “worker” refers to the role of doing background tasks that are either independent or can run in parallel with the main tasks of the application.

What is a Core?

A core is the basic computational unit of a CPU
Modern CPUs can have multiple cores, each capable of executing its own thread or process independently.
A multi-core processor can run multiple instructions at the same time, making it ideal for parallel processing.
Example: A quad-core CPU can run four threads or processes at once

Hyper-Threading?

Hyper-threading is a technology used by some CPUs where each core can execute two threads simultaneously, increasing the total number of threads the CPU can handle.
For example, a quad-core CPU with hyper-threading can run up to eight threads at the same time.

Physical Core vs. Logical Core

When we talk about cores in a CPU, we refer to the hardware responsible for executing tasks. However, there are two types of cores to understand:

Physical Core

A physical core is a real, hardware processing unit inside the CPU. Each physical core can execute instructions independently of other cores.
A quad-core processor has 4 physical cores, meaning the CPU can execute 4 different tasks simultaneously, each on its own core.

Logical Core

A logical core refers to a virtual or software-based core created by simultaneous multithreading (SMT) technology, such as Intel’s Hyper-Threading. With hyper-threading, each physical core is divided into two logical cores, meaning it can handle two separate instruction streams (threads) at once.
A quad-core processor with hyper-threading has 4 physical cores but 8 logical cores. This allows the CPU to handle 8 threads or tasks at once, even though there are only 4 physical cores.

Conclusion

Processes, threads, workers, and cores are foundational concepts in modern computing, each playing a specific role in managing how tasks are executed on a system. Processes offer isolation, threads allow for concurrency within a process, workers handle background tasks, and cores provide the hardware support for parallelism. Understanding these concepts is key to designing efficient, scalable software systems capable of handling complex, high-performance workloads.