Question

I am currently trying to write a concurrent queue, but I have some segfaults that I can’t explain to myself. My queue implementation is essentially given by the first listing on this site.

http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

The site says that there is a race condition if objects are removed from the queue in parallel, but I just don’t see why there is one, could anyone explain it to me?

Edit: This is the code:

template<typename Data>
class concurrent_queue
{
private:
    std::queue<Data> the_queue;
    mutable boost::mutex the_mutex;
public:
    void push(const Data& data)
    {
        boost::mutex::scoped_lock lock(the_mutex);
        the_queue.push(data);
    }

    bool empty() const
    {
        boost::mutex::scoped_lock lock(the_mutex);
        return the_queue.empty();
    }

    Data& front()
    {
        boost::mutex::scoped_lock lock(the_mutex);
        return the_queue.front();
    }

    Data const& front() const
    {
        boost::mutex::scoped_lock lock(the_mutex);
        return the_queue.front();
    }

    void pop()
    {
        boost::mutex::scoped_lock lock(the_mutex);
        the_queue.pop();
    }
};

Answer 1

If you use empty and find the queue is not empty, another thread may have popped the item making it empty before you use the result.

Similarly for front, you may read the front item, and it could be popped by another thread by the time you use the item.