No, there’s nothing wrong with your design, and it’s the normal approach taken for this sort of problem. It’s perfectly valid for you to have multiple conditions (eg anything on queue or program stopping) attached to a condition variable. The key thing is that the bits in the condition are checked for when the wait … Read more
You need to capture the this pointer: this->cv.wait(lk, [this]{return ready;});
This is not a definitive answer, but it’s supposed to cover the relevant details I’ve managed to gather about this problem. First, Python’s threading implementation is based on Java’s. Java’s Condition.signal() documentation reads: An implementation may (and typically does) require that the current thread hold the lock associated with this Condition when this method is … Read more
The difference is in how the wait duration is represented: wait_for takes a relative time (“wait for up to 10 seconds”), whereas wait_until takes an absolute time (“wait until 12:00 on October 30, 2012”). Compare the declarations of the time parameters: // wait_for: const std::chrono::duration<Rep, Period>& rel_time // wait_until: const std::chrono::time_point<Clock, Duration>& abs_time
You ask, What is the best way to wait on multiple condition variables in C++11? You can’t, and must redesign. One thread may wait on only one condition variable (and its associated mutex) at a time. In this regard the Windows facilities for synchronization are rather richer than those of the “POSIX-style” family of synchronization … Read more
If there are ten threads blocked on the condition variable, for example, notify_one() will unblock only one thread, while notify_all() will unblock them all. In your case, you’ll want to use notify_one() so you don’t wake up threads that don’t have any work waiting for them.
Simply put, you use a Condition when threads are interested in waiting for something to become true, and once its true, to have exclusive access to some shared resource. Whereas you use an Event when threads are just interested in waiting for something to become true. In essence, Condition is an abstracted Event + Lock, … Read more
On the page you refer to, “mutex” is the actual low-level synchronizing primitive. You can take a mutex and then release it, and only one thread can take it at any single time (hence it is a synchronizing primitive). A recursive mutex is one which can be taken by the same thread multiple times, and … Read more
Even though you can use them in the way you describe, mutexes weren’t designed for use as a notification/synchronization mechanism. They are meant to provide mutually exclusive access to a shared resource. Using mutexes to signal a condition is awkward and I suppose would look something like this (where Thread1 is signaled by Thread2): Thread1: … Read more
It is best to make the condition (monitored by your condition variable) the inverse condition of a while-loop: while(!some_condition). Inside this loop, you go to sleep if your condition fails, triggering the body of the loop. This way, if your thread is awoken–possibly spuriously–your loop will still check the condition before proceeding. Think of the … Read more