How to Use Condition Variable in C++
Condition variables are a powerful synchronization tool in C++ that allow threads to wait for a certain condition to become true before proceeding with their execution. They are often used in conjunction with mutexes to implement producer-consumer patterns, thread pools, and other multi-threaded applications. In this article, we will discuss how to use condition variables in C++ and provide examples to illustrate their usage.
First, let’s understand the basic components involved in using condition variables:
1. Mutex: A mutex is a synchronization primitive that ensures that only one thread can access a shared resource at a time. It is used to protect shared data and prevent race conditions.
2. Condition Variable: A condition variable allows one or more threads to wait until a certain condition becomes true. It is associated with a mutex and is used to coordinate the execution of threads.
3. Wait and Notify: Wait() is a method used by a thread to wait for a condition to become true. Notify() is a method used by a thread to wake up one or more waiting threads.
Now, let’s see how to use condition variables in C++ with an example:
“`cpp
include
include
include
std::mutex mtx;
std::condition_variable cv;
int count = 0;
void producer() {
for (int i = 0; i < 10; ++i) {
++count;
std::cout << "Produced " << count << std::endl;
mtx.lock();
cv.notify_one(); // Notify one waiting thread
mtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void consumer() {
while (true) {
mtx.lock();
while (count == 0) {
cv.wait(mtx); // Wait for the condition to become true
}
std::cout << "Consumed " << count << std::endl;
--count;
mtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main() {
std::thread prod(producer);
std::thread cons(consumer);
prod.join();
cons.join();
return 0;
}
```
In this example, we have a producer thread that generates numbers from 1 to 10 and a consumer thread that consumes these numbers. The producer increments the `count` variable and notifies the consumer thread using `cv.notify_one()`. The consumer thread waits for the condition `count > 0` to become true using `cv.wait(mtx)`.
To summarize, using condition variables in C++ involves the following steps:
1. Declare a mutex and a condition variable.
2. Lock the mutex before accessing shared data.
3. Use `cv.wait(mtx)` to make a thread wait until a condition becomes true.
4. Unlock the mutex and notify one or more waiting threads using `cv.notify_one()` or `cv.notify_all()`.
5. Repeat steps 2-4 as needed.
By following these steps, you can effectively use condition variables in your C++ applications to coordinate the execution of multiple threads.
