Using std::conditional_variable to wait on a condition

Question

For simplicity, let\'s assume that we have only one conditional variable to match a single condition that is reflected by a boolean.

1) Why does std::condition

Answer 1

No, your code will not work.

The mutex protects modifications to the shared variable. As such, all of the waiting threads and the signaling thread must lock that specific mutex instance. With what you've written, each thread has its own mutex instance.

The main reason for all of this mutex stuff is due to the concept of spurious wakeup, an unfortunate aspect of OS implementations of condition variables. Threads waiting on them sometimes just start running even though the condition hasn't been satisfied yet.

The mutex-bound check of the actual variable allows the thread to test whether it was spuriously awoken or not.

wait atomically releases the mutex and starts waiting on the condition. When wait exits, the mutex is atomically reacquired as part of the wakeup process. Now, consider a race between a spurious wakeup and the notifying thread. The notifying thread can be in one of 2 states: about to modify the variable, or after modifying it and about to notify everyone to wake up.

If the spurious wakeup happens when the notifying thread is about to modify the varaible, then one of them will get to the mutex first. So the spuriously awoken thread will either see the old value or the new value. If it sees the new, then it has been notified and will go do its business. If it sees the old, then it will wait on the condition again. But if it saw the old, then it blocked the notifying thread from modifying that variable, so it had to wait until the spurious thread went back to sleep.

Why does std::condition_variable::wait(...) locks the mutex again after a "notify" has been sent to un-sleep it?

Because the mutex locks access to the condition variable. And the first thing you have to do after waking up from a wait call is to check the condition variable. As such, that must be done under the protection of the mutex.

The signalling thread must be prevented from modifying the variable while other threads are reading it. That's what the mutex is for.

Seeing the behaviour in "1)", does that mean that when you do std::condition_variable::notify_all it only makes it so that all of the waiting threads are unblocked/woken up... but in order instead of all at once?

The order they wake up in is not specified. However, by the time notify_all returns, all threads are guaranteed to have been unblocked.

If I only care about threads sleeping until a condition is met and not care a single bit for any mutex acquisition, what can I do?

Nothing. condition_variable requires that access to the actual variable you're checking is controlled via a mutex.