std::condition_variable is a synchronization primitive used with astd::mutex to block one or more threads until another thread both modifies a shared variable (thecondition) and notifies thestd::condition_variable.

The thread that intends to modify the shared variable must:

1. Acquire astd::mutex (typically viastd::lock_guard).
2. Modify the shared variable while the lock is owned.
3. Callnotify_one ornotify_all on thestd::condition_variable (can be done after releasing the lock).

Even if the shared variable is atomic, it must be modified while owning the mutex tocorrectly publish the modification to the waiting thread.

Any thread that intends to wait on astd::condition_variable must:

1. Acquire astd::unique_lock<std::mutex> on the mutex used to protect the shared variable.
2. Do one of the following:

1. Check the condition, in case it was already updated and notified.
2. Callwait,wait_for, orwait_until on thestd::condition_variable (atomically releases the mutex and suspends thread execution until the condition variable is notified, a timeout expires, or aspurious wakeup occurs, then atomically acquires the mutex before returning).
3. Check the condition and resume waiting if not satisfied.

or:

1. Use the predicated overload ofwait,wait_for, andwait_until, which performs the same three steps.

std::condition_variable works only withstd::unique_lock<std::mutex>, which allows for maximal efficiency on some platforms.std::condition_variable_any provides a condition variable that works with anyBasicLockable object, such asstd::shared_lock.

Condition variables permit concurrent invocation of thewait,wait_for,wait_until,notify_one andnotify_all member functions.

The classstd::condition_variable is aStandardLayoutType. It is notCopyConstructible,MoveConstructible,CopyAssignable, orMoveAssignable.

[edit]Nested types

[edit]Member functions

[edit]Example

#include <condition_variable>#include <iostream>#include <mutex>#include <string>#include <thread> std::mutex m;std::condition_variable cv;std::string data;bool ready=false;bool processed=false; void worker_thread(){// wait until main() sends datastd::unique_lock lk(m);    cv.wait(lk,[]{return ready;}); // after the wait, we own the lockstd::cout<<"Worker thread is processing data\n";    data+=" after processing"; // send data back to main()    processed=true;std::cout<<"Worker thread signals data processing completed\n"; // manual unlocking is done before notifying, to avoid waking up// the waiting thread only to block again (see notify_one for details)    lk.unlock();    cv.notify_one();} int main(){std::thread worker(worker_thread);     data="Example data";// send data to the worker thread{std::lock_guard lk(m);        ready=true;std::cout<<"main() signals data ready for processing\n";}    cv.notify_one(); // wait for the worker{std::unique_lock lk(m);        cv.wait(lk,[]{return processed;});}std::cout<<"Back in main(), data = "<< data<<'\n';     worker.join();}

main() signals data ready for processingWorker thread is processing dataWorker thread signals data processing completedBack in main(), data = Example data after processing

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文