C++11 Can I ensure a condition_variable.wait() won

Question

I have thread 1 executing the following code:

unique_lock<mutex> ul(m);
while(condition == true)
    cv.wait(ul);

And thread 2 executing this code:

condition = false;
cv.notify_one();

Unfortunately I'm hitting a timing issue:

T1: condition checks true
                            T2: condition set to false
                            T2: cv.notify_one()
T1: cv.wait()

Thread 1 misses the notification completely and remains blocked on wait(). I tried using the version of wait() which takes a predicate but with essentially the same result. That is, the body of the predicate performs the check, but before it returns, the condition's value is changed and the notification is sent. The predicate then returns.

How can I fix this?

Answer 1

You have a data race because of the conflicting read/write access to condition. This implies that the behavior of your program is not defined.

The race condition on cv is the least of your worries: the program could do anything!

Answer 2

You should fix this race condition by having thread 2 lock the condition's mutex before changing the flag.

You are describing a typical race condition that happens for unprotected flags and conditions. These race conditions are the reason for the mutex lock pattern in condition usage. Put simply, always have a mutex protect the variables involved in checking a condition value.

In code for thread 2:

unique_lock<mutex> ul(m);
condition = false;
cv.notify_one();