Concurrency in Programming

Probably everyone who had to work with concurrency while writing their code (no matter in what language) experienced difficulties in mastering this topic. For me, it was once a difficult topic to understand, and I spent a lot of time figuring it out.
Below, there will be an briefly explanation of how I understood this concept. Perhaps someone will find it useful for themselves.

First, let’s look at what synchronous and asynchronous programming models are, and how single-threaded and multi-threaded scenarios are implemented in each of them. As you can see in the next diagram, each programming model (synchronous and asynchronous) can run in single-threaded and multi-threaded scenarios.

Synchronous Model

The synchronous programming model is a model where a thread is assigned one task and its execution begins. After completing the task, it becomes possible to take on another task. In this model, it is impossible to stop the execution of a task to perform another task in between.

Synchronous Model in Single-threaded scenario:

If we have several tasks to process and we can only work in a single-threaded scenario, then the tasks are executed in one thread one after another. The thread executes tasks one by one in the order that was set, and does not switch to the next one until it completes the current one. This is the basic code execution scenario in almost any programming language.

Synchronous Model in Multi-threaded scenario:

We also have several tasks and we use multiple threads to execute them. Each thread takes one task for execution. If the number of tasks is greater than the number of allocated threads, the first available thread, after completing the current task, takes a new one from the task pool. Note that each allocated thread consumes system resources (such as CPU and RAM), so the number of threads is usually limited within reasonable limits.

Asynchronous Programming Model

Unlike the synchronous programming model, here a thread, having started executing a task, can suspend its execution, save its current state, and begin executing another task.

Asynchronous Model in Single-threaded scenario:

We have one thread, but it is responsible for executing all tasks, and tasks alternate with each other.

Asynchronous Model in Multi-threaded scenario:

Please note that the same task is handled by multiple threads. As we can see, task Task 1 is first executed by thread Thread 1 and completed by thread Thread 4. Similarly, task Task 5 is executed by Thread 1, Thread 2, and Thread 3. This demonstrates the maximum use of threads.

Concurrency

So, we figured it out with these above aspects, and we can now clearly define what concurrency is. It is the processing of multiple tasks simultaneously.
In the synchronous model, this is a multi-threaded scenario - when several threads simultaneously execute several tasks.
And in the asynchronous model, these are both scenarios, both single-threaded and multi-threaded - multiple tasks are in the process of execution simultaneously, some of them are suspended, and some are being executed.