Forem: Lomas Singh

What is multithreading?

Lomas Singh — Sat, 25 Sep 2021 18:30:12 +0000

What is multithreading?

Multithreading is a CPU feature which allows creation and execution of multiple threads within a process concurrently or parallelly or both.

During development, the programmer divides the processes into threads i.e. separate units of semi-independent instructions extracted from the process. These threads are managed by the application.

With multithreading more than one user (here user can also be another program) can use a program at a time or even multiple requests by the same user can be managed by the program without having to run multiple copies of it in the computer.

Each user request for a program or system service is kept track of as a thread with a separate identity. There are some unique data incorporated in each thread that helps to identify them, such as:

Program counter: A program counter is responsible for keeping track of instructions and to tell which instruction to execute next.
Register: System registers are there to keep track of the current working variable of a thread.
Stack: It contains the history of thread execution.

As programs work on behalf of the initial request for that thread and are interrupted by other requests, the status of work on behalf of that thread is kept track of until the work is completed.

In multithreading, threads share the resources of a single or multi-cores.
Depending on the hardware, threads can run fully parallel if they are distributed to their own CPU core.

The execution in this is both concurrent and parallel:

Concurrent Execution: If the processor can switch execution resources between threads in a multithreaded process on a single processor, it is a concurrent execution.
Parallel Execution: When each thread in the process can run on a separate processor at the same time in the same multithreaded process, then it is said to be a parallel execution.

Examples of threads are several background/front end tasks such as updating data in the file system, capturing the log files, multiple windows operations management, file scanning, continuous interaction with users.

• Advantages of multithreading:

The main reason for incorporating threads into an application is to improve its performance.
It is usually used for its essential characteristics like it uses the system resources efficiently, high performance, greatly responsive, and also its parallel execution ability.

Threading can be useful in a single-processor system because it allows the primary execution thread to be responsive to user input while supporting threads execute long-running tasks in the background that do not require user intervention.

Application responsiveness is improved as requests from one thread do not block requests from other threads.

Additionally, multithreading is less resource-intensive than running multiple processes at the same time. There is much more overhead, time consumption, and management involved in creating processes as compared to creating and managing threads.

Regards,
Lomas Singh

Image credits

Cover image by freepik - www.freepik.com

Processes and Threads

Lomas Singh — Tue, 21 Sep 2021 08:11:31 +0000

This is part 2 of “Getting started with multithreading” series. Click here for part 1.

1) What are processes?

A process initializes a program. Programs are nothing but a passive collection of instructions stored in a file on a disk or simply our software.

A Process contains the program’s code and its activity. It’s the self-contained unit of execution that has all the things necessary to accomplish the mission.

A program doesn’t consume any memory; it is a passive entity whereas a process consumes some memory (RAM) and gets CPU time. It’s an instance of a program running on a computer.

A “program becomes a process" when loaded into memory (RAM) and thus is an active entity or a dynamic entity.

A program can have several processes; for example, opening several instances of the same program often results in more than one process being executed. Every process has its own memory space or address space.

To visualize in simple terms, consider a program as the McDonald company and its restaurants as the processes. The company has a set of rules and regulations for the operation of restaurants and recipes of the food, but the actual implementation of those rules and recipes is run by the restaurant.
And Threads(see below) are the workers in a particular restaurant.

2) What are threads?

A thread is a portion of the process. Thread is short for the thread of execution. It is a series of commands (a block of code) that exists as a unit of work.

A process may have several threads. Each of these threads executes semi-independently while sharing common information. They can run concurrently or in parallel inside the same process.

Each thread has its executor, and this executor can perform only one thread at a time.

Threads run in a shared memory space inside its process. If there is no need of sharing the shared resources then tasks can run concurrently inside the same thread, there is no need to run them in different threads. It is cheaper in terms of resources to arrange concurrent execution with time-slicing inside one thread.

A thread is also known as a lightweight process because of the system resources they consume, as compared with processes.

I found a very easy to understand analogy for threads on StackOverflow as follows:
Suppose you’re reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you left off.
One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.
If you have a roommate and she’s using the same technique, she can take the book while you’re not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.

Threads work in the same way. Just like you can share a book with your friend, many tasks can share a CPU.

In technical terms, an execution context (therefore a thread) consists of the independent set of values for the processor registers(for single-core).

The resources associated with a process include memory pages (all the threads in a process have the same view of memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process.

• What is time slicing?

A CPU is giving you the illusion that it’s doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation(Read above to understand “execution context”).

The operating system can manage multiple threads and assign a thread a piece (“slice”) of processor time before switching to another thread to give it a turn to do some work.

At its core, a processor can simply execute a command, it has no concept of doing two things at one time. The operating system simulates this by allocating slices of time to different threads.

Now, if you introduce multiple cores/processors into the mix, then things can actually happen at the same time. The operating system can allocate time to one thread on the first processor, then allocate the same block of time to another thread on a different processor. All of this is about allowing the operating system to manage the completion of your task while you can go on in your code and do other things.

The “execution inside the threads” can be synchronous or asynchronous but never parallel because of the “single executor per thread”.

• Process Vs Threads:

Each process has its own memory space whereas,
Threads use the memory of the process they belong to.
Communication between different processes is slow since processes have different memory addresses whereas,
Communications between threads are faster due to sharing of the same memory with the process they belong to.
Processes are independent of one another due to separate memory spaces whereas,
Threads run in shared memory space.
While one process is blocked, no other process can be executed until the first process is unblocked whereas,
If one thread is blocked and waiting, a second thread in the same task can run.
Every process has at least one thread as they do all the work. There is no such thing as a thread without a process or a process without a thread.
Each process starts with a thread called the main thread. It can initiate the creation of additional threads inside the application, and every newly created thread can do it as well.
Process management is the responsibility of the operating system whereas,
Thread management is the concern of the application.

Regards,
Lomas Singh

Image credits:

Cover photo by 8photo

Process image by onlyyouqj - www.freepik.com

Threads image by rawpixel.com - www.freepik.com

Time-slicing image by Racool_studio - www.freepik.com

Process vs threads image by jcomp - www.freepik.com

Synchronous, Asynchronous, Concurrency and Parallelism

Lomas Singh — Sun, 12 Sep 2021 11:44:35 +0000

This is part 1 of “Getting started with multithreading” series.
Before getting to multithreading let’s first prepare ourselves with some prerequisites i.e. Synchronous and Asynchronous programming, Concurrency and Parallelism.

1) What is Synchronous programming?

It is a programming workflow in which operations take place one by one.

The program moves to the next step when the current step has completed execution and has returned an outcome.
It has one executor only.

Most of the activities should go synchronously if their goal is to achieve some specific results.

Syntax:

Input -> processing -> output -> input -> processing -> output....

OR,

Task 1 -> Task 2 -> ……… Task n

E.g.- Words in a sentence, making a cup of tea, car assembling, etc

2) What is Asynchronous programming?

It is a programming workflow in which you can move to another operation before the previous one finishes.

Operations of this kind often emerge when there is a need for waiting. You begin a routine, and let it run in the background while you start your next, then at some point, say “wait for this to finish”.

It’s more like:
Start A -> B -> C -> D ->.... Wait for A to finish.

The advantage is that you can execute B,C and or D while A is still running in the background or on a separate thread (which we will get to know a bit later), so you can take better advantage of your resources and have fewer “hangs” or “waits”.

E.g.- You are eating your food on an aircraft while flying, or you are recording video while bungee jumping etc.

3) What is Concurrency?

It is an ability to execute multiple operations at the same time and no predefined order without affecting the final outcome.

Concurrency appears when there is a scarce shared resource, and workers compete for access to it.
The process of managing access to scarce shared resources for concurrent tasks is called Synchronization.

Concurrency can appear with one executor and with multiple.

For concurrency, it’s necessary to have:
more than one task in operation
at least one critical section (scarce shared resource required for task execution) for these tasks.

The second name of concurrency is multitasking because there is no such thing as concurrency for one task.

4) What is Parallelism?

Parallel processing is a method of simultaneously breaking up and running operations via multiple executors, thereby reducing processing time. These can be either several independent operations or one big task split into smaller subtasks and divided between workers.

Each task in parallel processing is running in a continuous period as a whole unit process.

The parallel execution is possible only if there is more than one executor.
Since there are many executors processing tasks in parallel, the second name of parallelism is multiprocessing.

• What is the difference between concurrency and parallelism?

Parallelism is, in some sense, a concurrency without a limited resource for task execution. If shared resources are sufficient for all participants, processes can run in parallel. They don’t need to compete for resources and get access to it by turn because we distribute tasks among several executors so that everyone has only one.

In concurrency two or more operations can start, run and complete in overlapping time periods. It doesn’t necessarily mean they’ll ever be running at the same instant, e.g.- multitasking on a single-core machine.

But, Parallelism is when tasks literally run at the same time, e.g.- on a multicore processor.

Concurrency is a property of a program or system whereas Parallelism is the run-time behavior of executing multiple operations at the same time.

To visualize in simple terms:
Concurrency is like having a juggler juggle many balls. Regardless of how it seems, the juggler is only catching/throwing one ball per hand at a time.
Parallelism is having multiple jugglers juggle balls simultaneously.

Use the term “parallel” when the simultaneous execution is assured or expected, and use the term “concurrent” when it is uncertain or irrelevant if simultaneous execution will be employed.

• Can we mix concurrency and parallelism together?

Concurrency and parallelism often intersect and appear together. They can mutate one to another.

Concurrency is dealing with lots of things at once whereas parallelism is about doing lots of things at once.

Concurrency can appear with one executor or with multiple whereas Parallelism appears only when there are multiple executors. Parallel tasks can become concurrent and so on.
Practically, all combinations of concurrency and parallelism are possible.

For example, you can drink a glass of water while giving a speech.
Here you can drink and speak simultaneously in several combinations. You can drink a whole glass of water and then complete your speech, or you can drink half of the water in the glass and then complete half of the speech, then repeat again, etc.

In parallelism, you deliver your speech in a team of two. You can drink water while letting your friend deliver the speech. This time, the two tasks are really executed simultaneously, and it’s called parallel.

Parallelism is a specific kind of concurrency where tasks are really executed simultaneously.

Link to my original post : https://iamlomas.medium.com/synchronous-asynchronous-concurrency-and-parallelism-9eb8336df120

Regards,
Lomas Singh