Thread-safe Queue with Condition Variables

Welcome back to another exciting lesson on lock-based concurrent data structures! In our previous unit, we explored how to implement a thread-safe stack using locks. As we progress, we're going to elevate our synchronization skills by incorporating condition variables. This lesson will help you build a thread-safe queue, which not only handles multiple access with locks but also communicates effectively between threads when specific conditions are met. It's like giving threads the ability to "wait" for the right moment to act. Let's explore this thrilling aspect of concurrent programming.

In this lesson, you'll grasp the concepts of implementing a thread-safe queue using both locks and condition variables. Condition variables are used to block a thread until a particular condition is met, contributing to efficient coordination between producer and consumer threads. Here’s a glimpse into what our thread-safe queue might look like:

class ThreadsafeQueue {
private:
    mutable std::mutex mut;
    std::queue<int> data_queue;
    std::condition_variable data_cond;

public:
    void push(int new_value) {
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(std::move(new_value));
        data_cond.notify_one();
    }

    void wait_and_pop(int& value) {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this] { return !data_queue.empty(); });
        value = std::move(data_queue.front());
        data_queue.pop();
    }

    bool try_pop(int& value) {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty()) {
            return false;
        }
        value = std::move(data_queue.front());
        data_queue.pop();
        return true;
    }

    bool empty() const {
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
};

Notice how std::condition_variable is used alongside std::mutex to allow threads to wait for a queue item to become available before proceeding. This unlocks more sophisticated synchronization techniques compared to simply using locks.

Let's examine the methods in our ThreadsafeQueue class:

• push(int new_value): Adds a new item to the queue and notifies a waiting thread if one exists. Notice, that we use std::move to transfer the value to the queue efficiently. The condition variable data_cond is used to signal the waiting thread that new data is available.
• wait_and_pop(int& value): Waits for the queue to become non-empty and then pops the front element. The data_cond.wait() method blocks the thread until the lambda function [this] { return !data_queue.empty(); } returns true.
• try_pop(int& value): Attempts to pop an item from the queue if it's not empty. This method doesn't block the calling thread.
• empty() const: Checks if the queue is empty.

Let's see how these methods work together to create a thread-safe queue that can be safely accessed by multiple threads that are pushing and popping items concurrently:

int main() {
    ThreadsafeQueue tsq;

    std::thread producer([&tsq] {
        for (int i = 0; i < 10; ++i) {
            tsq.push(i);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    });

    std::thread consumer([&tsq] {
        int value;
        for (int i = 0; i < 10; ++i) {
            tsq.wait_and_pop(value);
            std::cout << "Consumer got: " << value << std::endl;
        }
    });

    producer.join();
    consumer.join();

    return 0;
}

In this example, we have a producer thread that pushes values to the queue and a consumer thread that waits for the queue to become non-empty before popping the front element. The producer thread adds values to the queue every 100 milliseconds, and the consumer thread retrieves them as they become available. This demonstrates how condition variables can be used to synchronize threads effectively.

Mastering thread-safe queues with condition variables is crucial for scenarios where threads must collaborate closely to complete tasks. For instance, in a producer-consumer setup, producers add items to a queue while consumers retrieve them. Utilizing condition variables ensures that consumers don't waste resources by actively polling the queue but instead wait patiently for new data. This efficiency is essential for robust, high-performance applications.

By learning these techniques, you're equipping yourself with the tools to build reliable software systems that can perform seamlessly under concurrent workloads. This knowledge is a stepping stone to understanding complex multi-threaded systems and tackling real-world programming challenges with confidence. Ready to see this in action? Let's move to the practice section and put your new skills to the test!