Mutex (Mutual Exclusion)

Avoiding race condition Way to synchronize access to critical section

Semaphores

Locks

RAII wrappers over mutexes
std::lock_guard

std::unique_lock - mutex ownership wrapper allowing deferred locking, time-constrained attempts at locking, recursive locking, transfer of lock ownership and use with condition variables

std::scoped_lock - deadlock avoiding RAII wrapper for multiple mutexes

std::lock - locks specified (can be more than one) mutexes, blocks if they are unavailable

Reader-writer locks, Shared mutex, shared lock

Thread Synchronization / Communication

Condition Variables

Promise-Future

std::async

Asynchronous Function calls

std::packaged_task

std::async can take any callable object as argument. Below code snippet shows usage with a function, function object and a lambda.

#include <iostream>
#include <future>
#include <string>

std::string callableFunc(const std::string& str)
{
    return str + " returned from function.\n";
}

struct CallableFuncObj{
    std::string operator()(const std::string& str) const
    {
        return str + " returned from function struct.\n";
    }
};

int main()
{
    std::string hw = "Hello World ";
    CallableFuncObj funcObj;
    auto funcFut = std::async(callableFunc, hw);
    auto funcStrFut = std::async(funcObj, hw);
    auto lambdaFut = std::async([](const std::string& str){ return str + " returned from lambda.\n";}, hw);

    std::cout << funcFut.get();
    std::cout << funcStrFut.get();
    std::cout << lambdaFut.get();

    return 0;
}

Concurrent or Deferred Execution

The callable object can be executed at the moment the call to async is made or can be deferred to a later point in time by passing an extra argument to the async call.

std::launch::async - It tells the compiler to launch a separate thread to execute the callable object and execute it immediately.

std::launch::deferred - It tells the compiler to perform the execution of callable object in the same thread and delay it to the point when the result is asked for.

Concurrent Execution:
In the example below, the function gets executed even before the get call to future is made. And it can also been seen that it is executed in separate thread.

Deferred Execution:
In the example below, the function gets executed when the get call to future is made. And it can also been seen that it is executed in same thread.

std::string callableFunc(const std::string& str)
{
    std::cout << "Function thread: " << std::this_thread::get_id() << "\n";
    return str + " returned from function.\n";
}

int main()
{
    std::string hw = "Hello World ";
    std::cout << "Main thread: " << std::this_thread::get_id() << "\n";
    auto funcFut = std::async(std::launch::async, callableFunc, hw);
    //auto funcFut = std::async(std::launch::deferred, callableFunc, hw);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Get value from future\n";
    std::cout << funcFut.get() << "\n";

    return 0;
}

Output for std::launch::async- 
Main thread: 140640628083456
Function thread: 140640620901952
Get value from future
Hello World  returned from function.

Output for std::launch::deferred- 
Main thread: 140249498356480
Get value from future
Function thread: 140249498356480
Hello World  returned from function.

The functionality provided by concepts can be achieved using static_assert and type_traits as well. For example, we can put constraint on template parameters in following way:

template <typename T>
void print_number(T n)
{
    static_assert(std::is_integral_v, "Must pass an integral value");
    std::cout << "n: " << n << "\n";
}

Concepts provide a more neater and readable way to add these constraints.

Adding concept to function template

Example using built-in concepts

template <typename T>
requires std::integral<T>
T sum(T a, T b)
{
    return a+b;
}

int a0 = 10;
int a1 = 20;
std::cout << sum(a0,a1) << "\n"; // 30

double b0 = 1.3;
double b1 = 2.6;
std::cout << sum(a0,a1) << "\n"; // Compiler Error: integral concept is not satisfied

Below are two other way/syntax to write the same concept

template <std::integral T>
T sum(T a, T b)
{
    return a+b;
}

auto add(std::integral auto a, std::integral auto b)
{
    return a + b;
}

template <typename T>
T add (T a, T b) -> requires std::integral<T>
{
    return a + b;
}

Custom Concepts

Different ways to write custom concepts

template <typename T>
concept MyIntegral = std::is_integral_v<T>;

template <typename T>
concept Multipliable = requires(T a, T b){
    a * b;
};

template <typename T>
concept Incrementable = requires(T a){
    // it makes sure that below three statements are valid syntax
    // for the template parameter type T
    // e.g. int would be ok but string would fail
    a+=1;
    a++;
    ++a;
};

Once our custom concepts have been created, they can be used in the same way as we used built-in concepts Example Below:

#include <concepts>
#include <iostream>
#include <type_traits>
#include <string>

template <typename T>
concept Incrementable = requires (T a){
    a+=1;
    a++;
    ++a;
};

template <typename T>
requires Incrementable<T> 
T add(T a, T b)
{
    return a + b;
}

int main()
{
    int a{1};
    int b{19};
    std::cout << add(a,b) << "\n"; // 20

    std::string c{"Hello"};
    std::string d{"World"};
    //std::cout << add(c,d) << "\n"; // Compiler Error
    return 0;
}

Lambda functions are inline functions that are designed to be used for small code which will not be reused and thus is not worth naming.

The basic syntax of lambda functions is as below:

[capture clause] (parameters) -> return type
{
  function body
}

Capture Clause

Lambda functions can capture the variables from the enclosing scope. By capture, we mean if a particular variable can be used inside a lambda function.

The variables can be captured in three ways:

• Capture by reference
  • [&] -> All the variables from the enclosing scope will be captured by reference.
  • [&a] -> Instead of capturing all the variables, one specific variable a can also be captured by reference. Then no other variable will be accessible inside the lambda function.
• Capture by value
  • [=] -> All the variables from the enclosing scope will be captured by value.
  • [a] -> Instead of capturing all the variables, one specific variable a can also be captured by value. Then no other variable will be accessible inside the lambda function.
• Mixed capture
  • The above two mentioned captures can be used in any possible combination.
  • [a,&b] -> Variable a is captured by value, variable b is captured by reference.
  • [=,&b] -> Variable b is captured by reference. All other variables are captured by value.

An empty [] means that no variable from enclosing scope is accessible inside the lambda body.

Return Type

It is optional to specify the return type of the function. The compiler can deduce automatically what would be the return type. But in some complex cases, it might be helpful to specify it explicitly.

Example

The code below shows a simple example of lambda usage. A number defined by variable ‘noToAdd’ is added to each entry in a vector.

#include <algorithm>
#include <vector>

int main()
{
	int noToAdd = 8;
	std::vector<int> vecOfNums{3,2,7,8,4,6};

	// noToAdd captured by reference
	std::for_each(vecOfNums.begin(), vecOfNums.end(), [&noToAdd](int num) {return num + noToAdd; });

	// noToAdd captured by value
	std::for_each(vecOfNums.begin(), vecOfNums.end(), [noToAdd](int num) {return num + noToAdd; });
	return 0;
}

Capture Member Variable or This pointer in Lambda

Member Variables can be captured by value and reference inside the member functions as shown in the example below:

class Test{
  public:
    Test(): _data(50){}
    void print()
    {
      [=](){ std::cout << _data << "\n"}();
    }
  private:
    int _data;
};

Capturing This pointer

Since C++11, this pointer could only be captured by reference. Usage of both [=] and [&] implicitly captures this by reference. This leads to problems when the object is temporary or goes out of scope leading to dangling reference.

struct Example{
  int m_x = 0;

  void func()
  {
    // m_x by ref, implicitly captures this by ref 
    [&](){};

    // m_x by ref, explicilty captures this by ref
    // redundant 
    [&, this](){};

    // m_x by value, implicitly captures this by ref 
    [=](){};

    // error: not allowed
    [=, this](){};
  }

};

Value capture of this pointer was added in C++17 to avoid above mentioned problems. This means lambda gets its own copy of this, allowing modifications without affecting the original object. Since C++17, use of [this] captures this by reference and use of [this] captures this by value.

C++ STL provides std::map container which maps a key to a value and maintains the key in an ordered fashion. Another STL container std::unordered_map also maps a key to a value but no ordering is maintained. Two values can not have the same key in both containers.

Below code shows the difference between the two. In the case of ordered map, the order of the keys is maintained irrespective of the order in which they are entered.

#include <iostream>
#include <map>
#include <unordered_map>

int main()
{
	std::map<std::string, std::string> empRecords;

	// insert an entry
	empRecords.insert({ "MAR", "Maria" });
	empRecords["CHR"] = "Christoph";
	empRecords.insert(std::make_pair("SEB", "Sebastian"));

	std::cout << "Employee Records using Ordered Map\n";
	for (const auto& [key, val] : empRecords)
		std::cout << "Emp Code: " << key << " , Emp Name: " << val << std::endl;

	std::cout << std::endl << std::endl;

	std::unordered_map<std::string, std::string> empRecordsUnOrder;

	// insert an entry
	empRecordsUnOrder.insert({ "MAR", "Maria" });
	empRecordsUnOrder["CHR"] = "Christoph";
	empRecordsUnOrder.insert(std::make_pair("SEB", "Sebastian"));

	std::cout << "Employee Records using Unordered Map\n";
	for (const auto& [key, val] : empRecordsUnOrder)
		std::cout << "Emp Code: " << key << " , Emp Name: " << val << std::endl;

	return 0;
}

Output:
Employee Records using Ordered Map
Emp Code: CHR , Emp Name: Christoph
Emp Code: MAR , Emp Name: Maria
Emp Code: SEB , Emp Name: Sebastian


Employee Records using Unordered Map
Emp Code: MAR , Emp Name: Maria
Emp Code: CHR , Emp Name: Christoph
Emp Code: SEB , Emp Name: Sebastian

Internally, the maps are implemented using Self-balancing Binary Search Tree (like Red-Black Tree). That is how the key order is maintained. Due to this, ordered maps are expensive in insertion, deletion and search operations. The complexity of all three operations is log(n). Also the maps needs to reordered after every insert and delete operation.

On the other hand, unordered maps are implemented using Hash Table since they don’t require any ordering. The average time complexity is O(1) and O(n) in worst case for insert, delete and search operations.

Multimaps

We read above about maps and that every key in a map should be unique i.e. no two values can have the same key. Multimap is different in a way that it can store two values with same key. Similar to maps, C++ STL provides ordered multimaps (std::multimap) and unordered multimaps (std::unordered_multimap). Ordered multimaps store the keys in sorted order. Unordered multimaps store the keys in random order, but the pairs with same key value are stored together. Internal implementation is similar to maps.

Sets are different from maps in a way that map stores key-value pairs whereas set stores only keys. C++ STL provides std::set container which stores the elements in sorted order.
Another STL container std::unordered_set stores the elements in random order. All the elements should be unique in both the containers.

An example usage is as below:

#include <iostream>
#include <set>
#include <unordered_set>

int main()
{
	std::set<std::string> empNames;

	// insert an entry
	empNames.insert("Maria");
	empNames.insert("Christoph");
	empNames.insert("Sebastian");

	std::cout << "Employee Names using Ordered set\n";
	for (const auto& name : empNames)
		std::cout << "Emp Name: " << name << std::endl;

	std::cout << std::endl << std::endl;

	std::unordered_set<std::string> empNamesUnOrder;

	// insert an entry
	empNamesUnOrder.insert("Maria");
	empNamesUnOrder.insert("Sebastian");
	empNamesUnOrder.insert("Christoph");

	std::cout << "Employee Names using Unordered Set\n";
	for (const auto& name : empNamesUnOrder)
		std::cout << "Emp Name: " << name << std::endl;

	return 0;
}

Output:
Employee Records using Ordered Map
Emp Code: CHR , Emp Name: Christoph
Emp Code: MAR , Emp Name: Maria
Emp Code: SEB , Emp Name: Sebastian


Employee Records using Unordered Map
Emp Code: MAR , Emp Name: Maria
Emp Code: CHR , Emp Name: Christoph
Emp Code: SEB , Emp Name: Sebastian

Internally, the maps and sets are implemented in the same manner. The sets are implemented using Self-balancing Binary Search Tree (like Red-Black Tree). The complexity of all three operations - search, insert and delete is log(n). Unordered sets are implemented using Hash Table. The elements of the unordered set are hashed into indices of the hash table so that the insertion is always randomized. The average time complexity is O(1) and O(n) in worst case for insert, delete and search operations.

Multisets

We read above about sets and that each element in the set should be unique i.e sets does not allow duplicate elements. Multisets are different from sets in a way that it allows duplicate values. Like sets, multisets are also ordered (std::multiset) and unordered (std::unordered_multiset). The internal implementation of ordered/unordered multiset is similar to ordered/unordered set in that they both use self-balancing BST/hash table, but in case of multiset, a separate count value is also associated with each element to denote the number of entries for each element.