conditionvariableany

condition_variable_any is a synchronization primitive in the C++ standard library that enables threads to wait for a condition using any type of lock that models the Lockable concept. It is defined in the header <condition_variable> and is part of the same family as std::condition_variable, but it offers greater flexibility.

The class itself is not templated on a specific lock type. Instead, its member functions are templates that accept a Lock parameter. This allows waiting on resources protected by custom or non-standard locks, such as spinlocks or wrappers around existing mutexes, provided the lock type exposes lock() and unlock() operations. The primary interface includes wait, wait_for, wait_until, and their predicate-enabled variants, as well as notify_one and notify_all.

Semantics and usage: wait(lock) releases the provided lock, blocks the calling thread until another thread notifies the condition variable, and then reacquires the lock before returning. wait with a predicate repeatedly wakes and checks the predicate, guarding against spurious wakeups. wait_for and wait_until perform timed waits and return a status indicating whether the predicate became true or the timeout expired. notify_one wakes a single waiting thread; notify_all wakes all waiting threads.

Comparison: std::condition_variable requires a specific locking form, typically std::unique_lock<std::mutex>, while condition_variable_any works with any Lock type that supports lock/unlock. This makes it suitable for heterogeneous synchronization schemes, but it may be used more cautiously to avoid subtle locking mistakes.

In practice, condition_variable_any is used to coordinate producer-consumer scenarios or other inter-thread communication where the protected data is guarded by non-standard or user-defined locks, providing a flexible and portable synchronization mechanism.