Concurrency vs Parallelism in C++

In C++, concurrency and parallelism are often used interchangeably, but they refer to different concepts. Understanding these differences is crucial for writing efficient multi-threaded programs.

Concurrency refers to the ability of a program to handle multiple tasks at once. These tasks can be part of the same process and may run on the same core.

Concurrency involves context switching, where the CPU switches between different tasks, giving the illusion that they are running simultaneously.

In a concurrent program, tasks may not necessarily execute at the same time, but they can start, run, and complete in overlapping periods.

Parallelism, on the other hand, is about performing multiple operations simultaneously. It requires multiple cores or processors.

Parallelism aims to speed up computations by dividing tasks into smaller sub-tasks that can be executed simultaneously on different cores. This reduces the total time required to complete a task.

Here’s a simple example to illustrate the difference.  Concurrency:

1#include <iostream>
2#include <thread>
3
4void Task1() {
5  std::cout << "Task 1 running\\n";
6}
7
8void Task2() {
9  std::cout << "Task 2 running\\n";
10}
11
12int main() {
13  std::thread t1(Task1);
14  std::thread t2(Task2);
15
16  t1.join();
17  t2.join();
18  return 0;
19}

1Task 1 running
2Task 2 running

Parallelism:

1#include <iostream>
2#include <vector>
3#include <execution>
4#include <algorithm>
5
6void Log(int number) {
7  std::cout << "Number: " << number << '\n';
8}
9
10int main() {
11  std::vector<int> numbers{1, 2, 3, 4, 5};
12
13  std::for_each(
14    std::execution::par,
15    numbers.begin(),
16    numbers.end(),
17    Log
18  );
19}

1Number: 1
2Number: 4
3Number: 5
4Number: 2
5Number: 3

In the concurrency example, Task1 and Task2 can run on the same core, switching context. In the parallelism example, Log() operations run simultaneously on multiple cores.

Understanding these differences helps you decide when to use concurrency (improving responsiveness) or parallelism (improving performance) in your programs.