如何阻止直到满足条件

Question

I wanted to know what the best way is to block a method until a condition becomes true.

Example:

class DoWork
{
  int projects_completed;
  public:
  .....
  void WaitForProjectsCompleted()
  {
   ---->//How do I block until projects_completed == 12;
  }
};

I want it to be used as such

class foo
{
 ....
 void someMethod()
 {
    DoWork work;
    work.WaitForProjectsCompleted();//This should block
 }
}

Answer 1

Assuming that there's another thread that's actually going to do something here, an easy thing to use is a std::condition_variable :

std::condition_variable cv;
std::mutex mtx;

void WaitForProjectsCompleted() {
    std::unique_lock<std::mutex> lk(mtx);
    cv.wait(lk, [this]{ 
       return projects_completed >= 12; 
    });
}

Where somewhere else, some other member function might do:

void CompleteProject() {
    {
        std::lock_guard<std::mutex> lk(mtx);
        ++projects_completed;
    }
    cv.notify_one(); // let the waiter know
}

---

If projects_completed is atomic, you could instead just spin:

void WaitForProjectsCompleted() {
    while (projects_completed < 12) ;
}

That would work fine too.

Answer 2

Condition variables are an excellent synchronization primitive, and in my personal experience it is the tool I respond with to 95% of synchs/threading situations.

If you don't have C++11 available you can use boost::condition_variable .
In which case you won't have the wait version with a predicate (because no lambdas in C++03). So you absolutely need to remember to loop over your condition check. As explained in the docs:

boost::unique_lock<boost::mutex> lock(mut);
while (projects_completed < 12)
{
    wait(lock);
}

cf:
http://www.boost.org/doc/libs/1_58_0/doc/html/thread/synchronization.html#thread.synchronization.condvar_ref

That's because you get no guarantee that the condition is fulfilled after a notification, particularly because the lock can be acquired by another thread in the interstice between unlock and notify. Also a spurious wake up could happen.

I also wrote an article about it:
http://www.gamedev.net/page/resources/_/technical/general-programming/multithreading-r3048

Also if you use timed_wait (and I recommend it as it often mitigates priority inversion ), another trap not to fall into is the timeout, because of the loop you cannot use a relative timeout (like 2 seconds) you need an absolute system time determined before entering the loop.
boost makes it very clean with this technique:

system_time const timeout = get_system_time() + posix_time::seconds(2);

About the spin lock pattern proposed by Barry, I would not recommend it, unless you are in a real time environment, like playstation 3/4 or equivalent. Or unless you are sure it won't last for more than a few seconds.
By using spin locking you waste power, and you don't leave chance for CPU to enter sleep states (cf intel speed step).
This also has consequences on fairness and scheduling, as explained on wikipedia:
https://en.wikipedia.org/wiki/Spinlock

Finally if you don't have boost, since windows Vista we get natives Win32 functions:
SleepConditionVariableCS
https://msdn.microsoft.com/en-us/library/windows/desktop/ms686301(v=vs.85).aspx