Question

I am implementing a C++ message queue based on a std::queue.

As I need popers to wait on an empty queue I was considering using mutex for mutual exclusion and cond for suspending threads on empty queue, as glib does with the gasyncqueue.

However it looks to me that a mutex&semaphore would do the job, I think it contains an integer and that seems like a pretty high number to reach on pending messages.

Pros of semaphore are that you don’t need to check manually the condition each time you return from a wait, as you now for sure that someone inserted something(when someone inserted 2 items and you are the second thread arriving).

Which one would you choose?

EDIT:
Changed the question in response to @Greg Rogers

Answer 1

A single semaphore does not do the job – you need to be comparing (mutex + semaphore) and (mutex + condition variable).

It is pretty easy to see this by trying to implement it:

void push(T t)
{
    queue.push(t); 
    sem.post();
}

T pop()
{
    sem.wait();
    T t = queue.top();
    queue.pop();
    return t;
}

As you can see there is no mutual exclusion when you are actually reading/writing to the queue, even though the signalling (from the semaphore) is there. Multiple threads can call push at the same time and break the queue, or multiple threads could call pop at the same time and break it. Or, a thread could call pop and be removing the first element of the queue while another thread called push.

You should use whichever you think is easier to implement, I doubt performance will vary much if any (it might be interesting to measure though).