Thread-safe Stack using Locks

Welcome to the first lesson in our course on lock-based concurrent data structures. Here, we will delve into implementing a thread-safe stack using locks in C++. You may remember that we've already touched upon the topic of synchronization mechanisms like std::mutex in past discussions. This lesson provides a hands-on approach to exploring how locks can help us ensure thread safety and consistency when accessing shared resources. Let’s embark on this journey where you'll transform typical data structures into robust, concurrent ones.

In this lesson, you will learn how to create a stack that multiple threads can access without encountering race conditions. A thread-safe stack ensures that operations like pushing and popping elements can be performed safely across multiple threads. You'll employ std::mutex for synchronization, which is crucial for locking access to the stack and managing concurrent tasks effectively.

Here’s a quick look at what the core of our thread-safe stack will include:

class ThreadsafeStack {
private:
    std::stack<int> data;
    mutable std::mutex m;

public:
    void push(int new_value) {
        std::lock_guard<std::mutex> lock(m);
        data.push(std::move(new_value));
    }

    void pop(int& value)
    {
        std::lock_guard<std::mutex> lock(m);
        if (data.empty()) {
            throw std::runtime_error("Stack is empty!");
        }
        value = std::move(data.top());
        data.pop();
    }

    bool empty() const {
        std::lock_guard<std::mutex> lock(m);
        return data.empty();
    }
};

Let's break down both the methods:

• push(int new_value): This method pushes a new element onto the stack. It uses a std::lock_guard to lock the mutex m and ensure that only one thread can access the stack at a time. Notice that we use std::move to transfer the value to the stack, which is more efficient than copying.
• pop(int& value): This method pops the top element from the stack and stores it in the value reference. It also uses a std::lock_guard to lock the mutex m and prevent multiple threads from accessing the stack simultaneously. If the stack is empty, it throws a std::runtime_error. Again, we use std::move to transfer the value from the stack. Note, that the pop method of standard std::stack does not take any arguments, however, we have modified it to take a reference to an int to store the popped value for demonstration purposes.
• empty() const: This method checks if the stack is empty. It also uses a std::lock_guard to lock the mutex m and ensure that the operation is thread-safe.

We can use this stack in a multi-threaded environment without worrying about data corruption. Here is a sample usage with 10 threads pushing and 10 popping elements:

int main() {
    ThreadsafeStack stack;
    std::vector<std::thread> threads;

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&stack, i] {
            stack.push(i);
            std::cout << "Pushed: " << i << std::endl;
        });
    }

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&stack] {
            int value;
            stack.pop(value);
            std::cout << "Popped: " << value << std::endl;
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

In this lesson, you will learn how to implement a thread-safe stack using locks and understand the underlying concepts that make it work.