Question

I try to implement blocking queue. the main parts are the following (it’s a kind of educational task)

template <typename T>
class Blocking_queue
{
public:
    std::queue<T> _queue;
    boost::mutex _mutex;
    boost::condition_variable _cvar;

    void Put(T& object);
    T Get();
    void Disable()
};


template<typename T>
void Blocking_queue::Put(T& object)
{
    boost::mutex::scoped_lock lock(_mutex);
    _queue.push(T);
    lock.unlock();
     _cvar.notify_one();
}

template<typename T>
T Blocking_queue::Get()
{
    boost::mutex::scoped_lock lock(_mutex);

    while(_queue.empty())
    {
        _cvar.wait(_mutex);
    }

    T last_el = _queue.front();
    _queue.pop();
    return last_el;
}

template<typename T>
void Blocking_queue::Disable()
{

}

And i need to implement a function Disable() “releasing” all waiting threads (as written in the task). The problem is that i don’t fully understand what “releasing” in this terms means, and what methods should i apply. So my idea – is the following: when Disable() is called we should call some method for current thread in this place (inside the loop)

    while(_queue.empty())
    {
        //here
        _cvar.wait(_mutex);
    }

which will release current thread, am i right? Thanks.

Answer 1

“releasing all threads that are waiting” is an operation that is hardly useful. What do you want to do with this operation?

What is useful, is to shutdown the queue, thus every thread waiting on the queue will be unblocked and every thread that is going to call Get() will return immediately. To implement such a behaviour, simply add a shutdown flag to the queue and wait for “not empty or shutdown”:

template<typename T>
void Blocking_queue::Disable()
{
    boost::mutex::scoped_lock lock(_mutex);
    _shutdown = true;

    _cvar.notify_all()
}

To indicate that there is no data, to the caller of Get(), you could return a pair with an additional bool or throw a special exception. There is no way to return null, as not for all types T there is a null value.

template<typename T>
std::pair< bool, T > Blocking_queue::Get()
{
    boost::mutex::scoped_lock lock(_mutex);

    while  (_queue.empty() && !_shutdown )
        _cvar.wait(_mutex);

    if ( _shutdown )
        return std::make_pair( false, T() );

    T last_el = _queue.front();
    _queue.pop();
    return std::make_pair( true, last_el );
}