Exploring Inter-thread Communication with Condition Variables

Welcome to the next chapter in our journey through C++ concurrency. In our previous lesson, we delved into synchronization primitives using std::atomic and learned how to manage shared data effectively with lock-free programming. Building on that knowledge, this lesson will introduce you to inter-thread communication using condition variables. Condition variables are a crucial part of the concurrency toolkit, allowing threads to coordinate their activities seamlessly.

In this lesson, you'll gain a solid understanding of how to use condition variables for better inter-thread communication:

• Introduction to std::condition_variable: You'll learn about its purpose and how it enables threads to wait for certain conditions or events to occur before proceeding.

• Implementing Wait and Notify Patterns: We'll explore how to use the wait(), notify_one(), and notify_all() methods to manage thread execution flow.

A std::condition_variable is a synchronization primitive that allows threads to wait for a specific condition to be met before proceeding. It is often used in conjunction with a std::mutex to protect shared data and coordinate the activities of multiple threads. Condition variables provide a mechanism for threads to block efficiently, reducing CPU usage and improving responsiveness.

The key methods associated with std::condition_variable are:

• wait(lock): This method blocks the current thread until the condition variable is notified or a spurious wakeup occurs. It releases the lock associated with the std::unique_lock or std::lock_guard object passed as an argument, allowing other threads to acquire the lock.
• notify_one(): This method notifies one waiting thread, if any, that the condition has changed. The notified thread will wake up and attempt to reacquire the lock.
• notify_all(): This method notifies all waiting threads that the condition has changed. Each thread will wake up and attempt to reacquire the lock.

Consider the following code snippet, which demonstrates a simple example of using condition variables in action:

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

std::mutex print_mutex;           // Mutex for critical section
std::condition_variable cv;       // Condition variable to block thread
bool ready = false;               // Shared data (condition)

void print_id(int id) {
    std::unique_lock<std::mutex> lck(print_mutex);  // Acquire the lock
    while (!ready) cv.wait(lck);            // Wait until the condition is met. When the 'ready' flag is true, the thread will be unblocked and continue execution
    // Proceed after the condition is met
    std::cout << "Thread " << id << '\n';
}

void set_ready() {
    std::this_thread::sleep_for(std::chrono::seconds(3)); // simulate work
    {
        std::lock_guard<std::mutex> lck(print_mutex);  // Lock the mutex
        ready = true;                          // Set the condition to true
    }
    std::cout << "Threads are still waiting" << std::endl;
    cv.notify_all();  // Notify all waiting threads that the condition has changed
}

int main() {
    std::thread threads[10];
    // Spawn 10 threads
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(print_id, i);
    }
    std::cout << "Threads are waiting for the condition to be met..." << std::endl;
    set_ready();  // Set the condition to true after 3 seconds
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

In this code snippet, we explore the use of condition variables for inter-thread communication through a simple example.

1. Mutex and Condition Variable Declaration: We begin by declaring a std::mutex (print_mutex) and a std::condition_variable (cv). The mutex is used to protect access to the shared data (ready), while the condition variable provides the mechanism for threads to block and be notified when the state changes.

2. Shared Data: The boolean flag ready indicates when the condition has been satisfied. Initially set to false, it determines whether a thread can proceed with its task.

3. Thread Function (print_id): Inside print_id, we acquire a std::unique_lock on the mutex print_mutex, ensuring exclusive access to the critical section. The thread then enters a loop where it calls cv.wait(lck) to block until the ready condition is met. Upon receiving a notification that the condition is satisfied, the thread resumes execution, enabling it to print its identifier.

4. Notifier Function (set_ready): The set_ready function simulates work by sleeping for 3 seconds. It then locks the mutex with std::lock_guard, sets the ready flag to true, and prints a message indicating that threads are waiting. Finally, cv.notify_all() is called to unblock all waiting threads. Note, that if you use notify_one() instead of notify_all(), only one thread will be unblocked - the thread is chosen non-deterministically.

5. Main Function: In the main function, we spawn 10 threads, each calling the print_id function. The threads are initially blocked by the condition variable, waiting for the ready flag to be set to true. After 3 seconds, the set_ready function is called, changing the condition and notifying all waiting threads. The threads are then unblocked and proceed to print their identifiers.

This code exemplifies a basic producer-consumer pattern, where set_ready acts as the producer that meets the condition, allowing the consumer threads in print_id to proceed with their task after the condition has changed.