Page History

The wait(), wait_for(), and wait_until() member functions of the std::condition_variable class temporarily cede possession of a mutex so that other threads that may be requesting the mutex can proceed. These functions must always be called from code that is protected by locking a mutex. The waiting thread resumes execution only after it has been notified, generally as the result of the invocation of the notify_one() or notify_all() member functions invoked by another thread.

The wait() function must be invoked from a loop that checks whether a condition predicate holds. A condition predicate is an expression constructed from the variables of a function that must be true for a thread to be allowed to continue execution. The thread pauses execution , via wait(), wait_for(), wait_until(), or some other mechanism, and is resumed later, presumably when the condition predicate is true and the thread is notified.

...

This thread pauses execution using wait() and resumes when notified, presumably when the list has elements to be consumed. It is possible for the thread to be notified even if the list is still empty, perhaps because the notifying thread used notify_all(), which notifies all threads. Notification using notify_all() is frequently preferred over using notify_one(). (see See CON55-CPP. Preserve thread safety and liveness when using condition variables for more information.).

Note that a condition A condition predicate is typically the negation of the condition expression in the loop. In this noncompliant code example, the condition predicate for removing an element from a linked list is (list->next != nullptr), whereas the condition expression for the while loop condition is (list->next == nullptr).

...

This compliant solution calls the wait() member function from within a while loop to check the condition both before and after the call to wait():.

#include <condition_variable>
#include <mutex>
 
struct Node {
  void *node;
  struct Node *next;
};
  
static Node list;
static std::mutex m;
static std::condition_variable condition;
  
void consume_list_element() {
  std::unique_lock<std::mutex> lk(m);
  
  while (list.next == nullptr) {
    condition.wait(lk);
  }
 
  // Proceed when condition holds.
}

...