Thread Signaling with std::condition_variable

Advanced14 min read•Updated: 2026-10-22

🚦 Thread Signaling with std::condition_variable

Introduction

Instead of making worker threads waste CPU cycles spinning in a busy loop (while (!dataReady) {}), std::condition_variable puts threads to sleep until another thread wakes them up with a signal. This is the cornerstone of the Producer-Consumer pattern.

📦 The Producer-Consumer Architecture

1#include <iostream>
2#include <thread>
3#include <queue>
4#include <mutex>
5#include <condition_variable>
6 
7std::queue<int> g_taskQueue;
8std::mutex g_queueMutex;
9std::condition_variable g_cv;
10bool g_finished = false;
11 
12// Worker (Consumer) Thread
13void consumerWorker() {
14    while (true) {
15        std::unique_lock<std::mutex> lock(g_queueMutex);
16 
17        // Sleep until queue has items OR finished flag is set:
18        // Predicate prevents Spurious Wakeups!
19        g_cv.wait(lock, [] { return !g_taskQueue.empty() || g_finished; });
20 
21        while (!g_taskQueue.empty()) {
22            int task = g_taskQueue.front();
23            g_taskQueue.pop();
24            std::cout << "Processed Task #" << task << "\n";
25        }
26 
27        if (g_finished) break;
28    }
29}
30 
31// Producer Thread
32int main() {
33    std::jthread worker(consumerWorker);
34 
35    // Push 5 tasks with simulated intervals:
36    for (int i = 1; i <= 5; ++i) {
37        {
38            std::lock_guard<std::mutex> lock(g_queueMutex);
39            g_taskQueue.push(i);
40            std::cout << "Enqueued Task #" << i << "\n";
41        }
42        g_cv.notify_one(); // Signal waiting consumer thread
43        std::this_thread::sleep_for(std::chrono::milliseconds(50));
44    }
45 
46    {
47        std::lock_guard<std::mutex> lock(g_queueMutex);
48        g_finished = true;
49    }
50    g_cv.notify_one(); // Wake up consumer to exit cleanly
51 
52    return 0;
53}

⚠️ Spurious Wakeups

Operating systems can occasionally wake up a thread even if no signal was sent. Always provide a boolean predicate lambda to cv.wait(lock, predicate) to guard against false wakeups.

Next Lesson

Asynchronous Tasks with std::async, std::future, and std::promise

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock	Asynchronous Tasks with std::async, std::future, and std::promise

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Asynchronous Tasks with std::async, std::future, and std::promise

Thread Signaling with std::condition_variable

Advanced14 min read•Updated: 2026-10-22

Study Materials

🚦 Thread Signaling with std::condition_variable

Introduction

📦 The Producer-Consumer Architecture

1#include <iostream>
2#include <thread>
3#include <queue>
4#include <mutex>
5#include <condition_variable>
6 
7std::queue<int> g_taskQueue;
8std::mutex g_queueMutex;
9std::condition_variable g_cv;
10bool g_finished = false;
11 
12// Worker (Consumer) Thread
13void consumerWorker() {
14    while (true) {
15        std::unique_lock<std::mutex> lock(g_queueMutex);
16 
17        // Sleep until queue has items OR finished flag is set:
18        // Predicate prevents Spurious Wakeups!
19        g_cv.wait(lock, [] { return !g_taskQueue.empty() || g_finished; });
20 
21        while (!g_taskQueue.empty()) {
22            int task = g_taskQueue.front();
23            g_taskQueue.pop();
24            std::cout << "Processed Task #" << task << "\n";
25        }
26 
27        if (g_finished) break;
28    }
29}
30 
31// Producer Thread
32int main() {
33    std::jthread worker(consumerWorker);
34 
35    // Push 5 tasks with simulated intervals:
36    for (int i = 1; i <= 5; ++i) {
37        {
38            std::lock_guard<std::mutex> lock(g_queueMutex);
39            g_taskQueue.push(i);
40            std::cout << "Enqueued Task #" << i << "\n";
41        }
42        g_cv.notify_one(); // Signal waiting consumer thread
43        std::this_thread::sleep_for(std::chrono::milliseconds(50));
44    }
45 
46    {
47        std::lock_guard<std::mutex> lock(g_queueMutex);
48        g_finished = true;
49    }
50    g_cv.notify_one(); // Wake up consumer to exit cleanly
51 
52    return 0;
53}

⚠️ Spurious Wakeups

Operating systems can occasionally wake up a thread even if no signal was sent. Always provide a boolean predicate lambda to cv.wait(lock, predicate) to guard against false wakeups.

Next Lesson

Asynchronous Tasks with std::async, std::future, and std::promise

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
RAII Lock Wrappers: std::lock_guard, std::unique_lock, std::scoped_lock	Asynchronous Tasks with std::async, std::future, and std::promise

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next