Wait and signal - std::condition_variable

Modules
	Basic functionality of condition variables - unsafe usage
	Using condition variables - the safe way
	Examples

Detailed Description

Within multithreaded environments a system's reaction to some internal or external trigger may consist of a series of small steps executed by multiple threads. The steps may be executed at least partly in parallel. Within such a scenario there is often the need that a thread has to wait until some preprocessing has reached some state before he can start or proceed with his own processing.

A simple approach for the waiting thread might be polling: he repeatedly checks some shared data until he recognizes that the data's state allows to start his own processing. If the state is not yet reached he sleeps for a small time interval and then repeats the check.

The typical disadvantages of this approach are:

• The repeated checks consume cpu load. Furthermore accessing shared data may require the need for repeatedly locking access to the data which may delay the work of other active threads which have to process the data.
• The reaction time depends on the time interval used for sleeping. Assume that at some point in time the conditions to start a thread's work are reached. But the thread may sleep for that time interval before he repeats the check and recognizes that he can start his part of processing.

To avoid these disadvantages you can use

• std::condition_variable
  Principle: Thread A waits on a condition, i.e. the thread is switched to inactive mode. Thread B finishes his actions and signals that the condition has become true. As a consequence thread A is triggered and continues his execution.