std::condition_variable

std::condition_variable

---

Prerequisites

---

1. What is condition_variable?

A std::condition_variable is a synchronization primitive that allows threads to:

• wait until a condition becomes true
• be notified by another thread

condition_variable lets threads sleep efficiently and wake up when work is available.

2. Why Do We Need It?

❌ Bad Approach (Busy Waiting)

while (queue.empty()) {}

- CPU usage is high
- Wasteful spinning

✔️ Better Approach

cv.wait(lock, condition);

- Thread sleeps (no CPU usage)
- Wakes only when needed

Basic Concept

Producer → produces data
Consumer → waits for data
condition_variable → notifies consumer

cv.wait() → sleep
while loop → spin

3. Example

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::mutex m;
std::condition_variable cv;
std::queue<int> q;

void producer()
{
    {
        std::lock_guard<std::mutex> lock(m);
        q.push(42);
    }

    cv.notify_one();  // wake one waiting thread
}

void consumer()
{
    std::unique_lock<std::mutex> lock(m);

    auto lmdCondition = []() { return !q.empty(); };

    cv.wait(lock, lmdCondition);

    int value = q.front();
    q.pop();

    std::cout << value << std::endl;
}

int main()
{
    std::thread t1(consumer);
    std::thread t2(producer);

    t1.join();
    t2.join();
}

How wait() Works Internally

1. lock is released
2. thread goes to sleep
3. notify_one() wakes it
4. lock is reacquired
5. condition is checked again

Important Rule (Predicate)

Always use a condition:

cv.wait(lock, [] { return !q.empty(); });

- Avoid spurious wakeups
- Ensure condition is actually satisfied

notify_one vs notify_all

Function	Description
notify_one	wakes one thread
notify_all	wakes all waiting threads

cv.notify_one(); // single worker
cv.notify_all(); // broadcast

✔️ Not a Lock

condition_variable does NOT protect data
→ mutex is required

✔️ Used with mutex

std::unique_lock<std::mutex> lock(m);
cv.wait(lock, condition);

✔️ Event-driven

Thread sleeps → wakes on notification

4. Common Mistakes

❌ Missing predicate

cv.wait(lock);  // dangerous

❌ Holding lock too long

lock → long computation → unlock ❌

Bad Example

std::lock_guard<std::mutex> lock(m);
shared_data = prepare_input();
long_computation();   // too long
shared_result = finalize();

Better Example

Better Example
int local_copy;
{
    std::lock_guard<std::mutex> lock(m);
    local_copy = shared_data;
}

long_computation(local_copy); // No lock

{
    std::lock_guard<std::mutex> lock(m);
    shared_result = local_copy;
}

❌ Forget notify

thread sleeps forever