Learn about advanced concurrency techniques to create parallel and vectorized programs.

Become a C++ Programmer

This module will help us study theoretical as well as practical parts of concurrency in C++. We'll go through the present and upcoming concurrency features of C++.  Moreover, we'll cover real-world scenarios and use-cases along with pitfalls and learn how to overcome them using best practices.

Concurrency with Modern C++



>_*Multithreading*_ in C++ consists of threads, synchronization primitives for shared data, thread-local data, and tasks.
$$$$
# Threads
A `std::thread` represents an independent unit of program execution. The executable unit, which is started immediately, receives its work package as a [callable unit](https://www.educative.io/courses/modern-cpp-concurrency-in-practice-get-the-most-out-of-any-machine/glossary). A callable unit can be a named function, a function object, or a lambda function.

The creator of a thread is responsible for its lifecycle. The executable unit of the new thread ends with the end of the callable. Either the creator waits until the created thread `t` is done (`t.join()`), or the creator detaches itself from the created thread: (`t.detach()`). A thread `t` is *joinable*  if no operation `t.join()` or `t.detach()` was performed on it. A *joinable* thread calls `std::terminate` in its destructor and the program terminates. 

A thread that is detached from its creator is typically called a daemon thread because it runs in the background. A `std::thread` is a variadic template. This means that it can receive an arbitrary number of arguments by copy or reference; either the callable or the thread can get the arguments.
$$$$
# Shared Data

You have to coordinate access to a shared variable if more than one thread is using it at the same time and the variable is mutable (non-const). Reading and writing a shared variable at the same time is a [data race](https://www.educative.io/courses/modern-cpp-concurrency-in-practice-get-the-most-out-of-any-machine/data-races), and therefore, undefined behavior. Coordinating access to a shared variable is achieved with mutexes and locks in C++.
$$$$
# Mutexes

A mutex (*mutual exclusion*) guarantees that only one thread can access a shared variable at any given time. A mutex locks and unlocks the [critical section](https://www.educative.io/courses/modern-cpp-concurrency-in-practice-get-the-most-out-of-any-machine/glossary) that the shared variable belongs to. C++ has five different mutexes; they can lock recursively, tentatively, and with or without time constraints. Even mutexes can share a lock at the same time.
$$$$
# Locks

You should encapsulate a mutex in a [lock](https://www.educative.io/courses/modern-cpp-concurrency-in-practice-get-the-most-out-of-any-machine/glossary) to release the mutex automatically. A lock implements the [RAII idiom](https://www.educative.io/courses/modern-cpp-concurrency-in-practice-get-the-most-out-of-any-machine/glossary) by binding a mutex's lifetime to its own. C++ has a `std::lock_guard` for the simple cases, and a `std::unique_lock` / `std::shared_lock` for the advanced use-cases, such as the explicit locking or unlocking of the mutex respectively. 
$$$$
# Thread-safe Initialization of Data

If shared data is read-only, it's sufficient to initialize it in a *thread-safe* way. C++ offers various ways to achieve this including using *constant expression*, a *static variable with block scope*, or using the function `std::call_once` in combination with the flag `std::once_flag`. 
$$$$
# Thread Local Data

Declaring a variable as *thread-local* ensures that each thread gets its own copy; therefore, there is no shared variable. The lifetime of a thread local data is bound to the lifetime of its thread. 
$$$$
# Condition Variables

*Condition variables* enable threads to be synchronized via messages. One thread acts as the sender while another one acts as the receiver of the message, where the receiver blocks wait for the message from the sender. Typical use cases for condition variables are producer-consumer workflows. A condition variable can be either the sender or the receiver of the message. Using condition variables correctly is quite challenging; therefore, tasks are often the easier solution.

$$$$
# Tasks

*Tasks* have a lot in common with threads. While you explicitly create a thread, a task is simply a job you start. The C++ runtime will automatically handle, in the simple case of `std::async`, the lifetime of the task. 

Tasks are like data channels between two communication endpoints. They enable thread-safe communication between threads: the promise at one endpoint puts data into the data channel, and the future at the other endpoint picks the value up. The data can be a value, an exception, or simply a notification. In addition to `std::async`, C++ has the class templates `std::promise` and `std::future` that give you more control over the task.

Illustrating the fundamentals of multithreading in C++.

Multithreading in C++

What is multithreaded programming in C++?