C++ 11 feature: C++ Multithreading Tutorial: Conditional Variables in C++ threading

A conditional variable is used to block and object until it is “notified” to makeup.

To use conditional variables, we need to use below header:

Conditional variable uses unique_lock to lock a thread when one of its wait functions is called.

Then that thread can be woken up by using notify function on the same condition variable.

wait: Wait until notified

wait_for: Wait for timeout

wait_until: Wait until notified

notify_one: Notify one can notify either a single thread or all of the threads

notify_all: Notify all is used to notify all the threads.

We can use this, in below scenario:

Suppose you have a bank account with 0 balance. In such case, if a withdraw and a deposit request comes at same time, withdraw request will need to wait till the deposit can happen.

In such cases, the withdraw can wait for some time and after deposit, it can notify the withdraw thread to withdraw money.

Now let us understand with the help of an example:

In the below example, I have created 2 methods. deposit() and withdraw().

In the main() function, we called withdraw first, as the initial balance is 0, it will wait till the deposit occurs.

Then we call deposit() function, it will deposit the money.

Then we shall notify the waiting thread.

Then the withdraw() will be called, and amount will be withdrawn.

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
#include <condition_variable>          // std::condition_variable

// for more tutorials on C, C++, DS visit www.ProDeveloperTutorial.com

using namespace std;

std::condition_variable cv;
std::mutex mtx;

int balance = 0;

void deposit(int money)
{
    std::lock_guard<mutex> lg(mtx);
    balance = balance + money;
    cout<<"The current balance is "<<balance<<endl;
    cv.notify_one();
}

void withdraw(int money)
{
    std::unique_lock <mutex> ul(mtx);

    cv.wait(ul, [] {
            return (balance != 0) ? true : false;
    });

   if ( balance >= money)
   {
        balance -= money;
        cout<<"The amount has been withdrawn"<<endl;
   }
   else
   {
        cout<<"The current balance is less than the amount"<<endl;
   }
        cout<<"The current balance is"<<balance<<endl;
}

int main ()
{
    std::thread t1 (withdraw, 400);
    std::thread t2 (deposit, 600);
    
    t1.join();
    t2.join();
  return 0;
}

Output:

The current balance is 600
The amount has been withdrawn
The current balance is 200