Is condition_variable.notify a synchronization point?

Question

Let's say I have something like this:

bool signalled = false;
std::condition_variable cv;
void thread1() {
  while (true) {
    std::unique_lock l(mutex);
    cv.wait_until(l, [] { return signalled; });
    return;
  }
}

void thread2...N() {
  signalled = true;
  cv.notify_all();
}

Is that considered thread-safe? The boolean may be set to true in many threads to interrupt thread1.

Edit: If not thread-safe I’m looking for a description of what the race condition is so I can better understand the underlying issue and fill in a knowledge gap.

Answer 1

Writing to a non-atomic variable without synchronization is UB. However, making signalled an atomic<bool> will not solve the problem.

C++ reference on std::condition_variable reads:

Even if the shared variable is atomic, it must be modified under the mutex in order to correctly publish the modification to the waiting thread.

You should do this:

bool signalled = false;

void thread2...N()
{
    std::unique_lock l(mutex);
    signalled = true;
    cv.notify_all();
}

Related questions:

• Mutex protecting std::condition_variable
• Shared atomic variable is not properly published if it is not modified under mutex
• Why do I need to acquire a lock to modify a shared "atomic" variable before notifying condition_variable