condition-variable

Suppose i have two thread and one shared c++ 11 condition variable. what happen if thread1 call notify and after that thread2 call wait? will thread2 block forever or it will continue it's work due to call of notify by thread1? Edit: enum bcLockOperation { bcLockOperation_Light = -1, bcLockOperation_Medium = 50, bcLockOperation_Heavy = 1 } class BC_COREDLL_EXP bcCustomMutex { private: bcCustomMutex(const bcCustomMutex&); bcCustomMutex& operator=(const bcCustomMutex&); protected: bcAtomic<int> mFlag; bcMutex mMutex; bcConditionVariable mCond; public: bcCustomMutex() { bcAtomicOperation:

I am trying to make a windows-version of a program written for Linux, in C++. For the program to be thread-safe, I use pthread_cond_t and pthread_cond_wait in the Linux version. These functions use a mutex to help make sure that the waiting thread is actually waiting. I found that CONDITION_VARIABLE may do the trick in Windows, however I can't figure out why it wont compile. I get the error "error: 'CONDITION_VARIABLE' does not name a type" even though all relevant headers are included, as far as I can tell. I tried copy-pasting the code on http://msdn.microsoft.com/en-us/library/ms686903%28v

Usually if I want to simulate some work or wait exact time interval I use condition_variable::wait_for or at the worst thread::this_thread::sleep_for . But condition_variable documentation states that wait_for or wait_until methods may block longer than was requested. This function may block for longer than timeout_duration due to scheduling or resource contention delays. How exact wait intervals can be guaranteed? UPDATE Can I reach it without condition_variable ? You cannot do this. In order to have exact guarantees like this, you need a real time operating system. C++ does not guarantee you

Consider the following example. std::mutex mtx; std::condition_variable cv; void f() { { std::unique_lock<std::mutex> lock( mtx ); cv.wait( lock ); // 1 } std::cout << "f()\n"; } void g() { std::this_thread::sleep_for( 1s ); cv.notify_one(); } int main() { std::thread t1{ f }; std::thread t2{ g }; t2.join(); t1.join(); } g() "knows" that f() is waiting in the scenario I would like to discuss. According to cppreference.com there is no need for g() to lock the mutex before calling notify_one . Now in the line marked "1" cv will release the mutex and relock it once the notification is sent. The

Do I need to synchronize std::condition_variable/condition_variable_any::notify_one ? As far as I can see, if lost of notifications is acceptable - it is OK to call notify_one not protected (by mutex for example). For instance, I saw following usage patterns (sorry, don't remember where): { { lock_guard<mutex> l(m); // do work } c.notify_one(); } But, I inspected libstdc++ sources, and I see: condition_variable::notify_one void condition_variable::notify_one() noexcept { int __e = __gthread_cond_signal(&_M_cond); // XXX not in spec // EINVAL if (__e) __throw_system_error(__e); } and condition

I've been working with pthreads a fair bit recently and there's one little thing I still don't quite get. I know that condition variables are designed to wait for a specific condition to come true (or be 'signalled'). My question is, how does this differ at all from normal mutexes? From what I understand, aren't condition variables just a mutex with additional logic to unlock another mutex (and lock it again) when the condition becomes true? Psuedocode example: mutex mymutex; condvar mycond; int somevalue = 0; onethread() { lock(mymutex); while(somevalue == 0) cond_wait(mycond, mymutex); if