了解std :: condition_variable

Question

I refer to the accepted answer here: Using std::conditional_variable to wait on a condition and in particular the code (copied):

struct gate {
  bool gate_open = false;
  mutable std::condition_variable cv;
  mutable std::mutex m;

  void open_gate() {
    std::unique_lock<std::mutex> lock(m);
    gate_open=true;
    cv.notify_all();
  }
  void wait_at_gate() const {
    std::unique_lock<std::mutex> lock(m);
    cv.wait( lock, [this]{ return gate_open; } );
  }
};

I don't understand how this works as an event class. How exactly does the code inside the mutex in open_gate execute if something is already waiting via the wait_at_gate functions. I'm guessing it has something to do with the std::condition_variable .

Answer 1

OK, since no one is going to post, here's my answer, helped by the comments and the following links (from which quoted text is from, which slight modification for readability):

http://en.cppreference.com/w/cpp/thread/condition_variable , http://en.cppreference.com/w/cpp/thread/condition_variable/wait , http://en.cppreference.com/w/cpp/thread/condition_variable/notify_all

It assumes two threads, one, named OG , calling open_gate() and the other, named WG , calling wait_at_gate() .

1) Both functions are protected with locks, it is a requirement that "any thread that intends to wait on std::condition_variable " acquires "a std::unique_lock<std::mutex> , on the same mutex as used to protect the shared variable".

2) If OG gets the lock first then it will open the gate before releasing the lock. WG then gets its lock, the gate is already opened. For this case since (from linked references):

while (!pred()) {
    wait(lock);
} 

then there is no wait.

3) If WG gets its lock first then its call to cv.wait "atomically releases the mutex and suspends the execution of the thread."

4) This allows OG to proceed, which then sets the shared flag. WG "will then be unblocked when notify_all() is executed" by OG .