C++ Library -

The in C++ is a synchronization primitive that allows threads to wait for certain conditions to be met before proceeding. It is useful in multi-threading applications, where one or more threads need to coordinate their actions based on shared data. By using condition variables, we can manage concurrent tasks, ensuring that threads either wait or proceed depending on specific conditions.

It is used in conjunction with std::mutex and is generally used with std::unique_lock. The unique_lock is passed to the condition_variable to release the lock when the thread is waiting, allowing the other threads to modify the shared data.

Including Header

To include the header in your C++ program, you can use the following syntax.

#include 

Functions of Header

Below is list of all functions from header.

Thread Waiting

In the following example, we are going to show how a thread can wait for a condition to be true.

#include 
#include 
#include 
#include 
std::mutex a;
std::condition_variable b;
bool ready = false;
void x() {
   std::unique_lock < std::mutex > lock(a);
   std::cout << "Waiting For Signal..." << std::endl;
   b.wait(lock, [] {
      return ready;
   });
   std::cout << "Signal Received" << std::endl;
}
int main() {
   std::thread y(x);
   std::this_thread::sleep_for(std::chrono::seconds(3));
   {
      std::lock_guard < std::mutex > lock(a);
      ready = true;
   }
   b.notify_one();
   y.join();
   return 0;
}

Output

Following is the output of the above code −

Waiting For Signal...
Signal Received