![]() |
Home | Libraries | People | FAQ | More |
condition_variable
condition_variable()
~condition_variable()
void notify_one()
void notify_all()
void wait(boost::unique_lock<boost::mutex>& lock)
template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>&
lock,
predicate_type pred)
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time
const&
abs_time)
template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>&
lock,duration_type const& rel_time)
template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>&
lock,
boost::system_time const& abs_time, predicate_type
pred)
template <class Clock, class Duration>
cv_status wait_until(boost::unique_lock<boost::mutex>& lock, const chrono::time_point<Clock, Duration>&
abs_time)
template <class Rep, class Period>
cv_status wait_for(boost::unique_lock<boost::mutex>& lock, const chrono::duration<Rep, Period>&
rel_time)
template <class Clock, class Duration, class Predicate> bool wait_until(boost::unique_lock<boost::mutex>&
lock,
const chrono::time_point<Clock, Duration>& abs_time, Predicate
pred)
template <class Rep, class Period, class Predicate> bool wait_for(boost::unique_lock<boost::mutex>&
lock,
const chrono::duration<Rep, Period>& rel_time, Predicate
pred)
condition_variable_any
condition_variable_any()
~condition_variable_any()
void notify_one()
void notify_all()
template<typename lock_type> void wait(lock_type&
lock)
template<typename lock_type,typename predicate_type>
void wait(lock_type& lock, predicate_type
pred)
template<typename lock_type> bool timed_wait(lock_type&
lock,boost::system_time const& abs_time)
template<typename lock_type,typename duration_type>
bool timed_wait(lock_type& lock,duration_type
const&
rel_time)
template<typename lock_type,typename predicate_type>
bool timed_wait(lock_type& lock, boost::system_time
const&
abs_time,
predicate_type pred)
template <class lock_type, class Clock, class Duration> cv_status
wait_until(lock_type&
lock,
const chrono::time_point<Clock, Duration>& abs_time)
template <class lock_type, class Rep, class Period> cv_status
wait_for(lock_type&
lock,
const chrono::duration<Rep, Period>& rel_time)
template <class lock_type, class Clock, class Duration, class Predicate>
bool wait_until(lock_type& lock, const chrono::time_point<Clock, Duration>&
abs_time,
Predicate pred)
template <class lock_type, class Rep, class Period, class Predicate>
bool wait_for(lock_type& lock, const chrono::duration<Rep, Period>&
rel_time,
Predicate pred)
condition
DEPRECATED V3notify_all_at_thread_exit
()namespace boost { enum class cv_status; { no_timeout, timeout }; class condition_variable; class condition_variable_any; void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); }
The classes condition_variable
and condition_variable_any
provide a mechanism for one thread to wait for notification from another
thread that a particular condition has become true. The general usage pattern
is that one thread locks a mutex and then calls wait
on an instance of condition_variable
or condition_variable_any
.
When the thread is woken from the wait, then it checks to see if the appropriate
condition is now true, and continues if so. If the condition is not true,
then the thread then calls wait
again to resume waiting. In the simplest case, this condition is just a boolean
variable:
boost::condition_variable cond; boost::mutex mut; bool data_ready; void process_data(); void wait_for_data_to_process() { boost::unique_lock<boost::mutex> lock(mut); while(!data_ready) { cond.wait(lock); } process_data(); }
Notice that the lock
is passed
to wait
: wait
will atomically add the thread to the set of threads waiting on the condition
variable, and unlock the mutex. When the thread is woken, the mutex will
be locked again before the call to wait
returns. This allows other threads to acquire the mutex in order to update
the shared data, and ensures that the data associated with the condition
is correctly synchronized.
In the mean time, another thread sets the condition to true
,
and then calls either notify_one
or notify_all
on the condition
variable to wake one waiting thread or all the waiting threads respectively.
void retrieve_data(); void prepare_data(); void prepare_data_for_processing() { retrieve_data(); prepare_data(); { boost::lock_guard<boost::mutex> lock(mut); data_ready=true; } cond.notify_one(); }
Note that the same mutex is locked before the shared data is updated, but
that the mutex does not have to be locked across the call to notify_one
.
This example uses an object of type condition_variable
,
but would work just as well with an object of type condition_variable_any
:
condition_variable_any
is
more general, and will work with any kind of lock or mutex, whereas condition_variable
requires that the lock
passed to wait
is an instance
of boost::unique_lock<boost::mutex>
.
This enables condition_variable
to make optimizations in some cases, based on the knowledge of the mutex
type; condition_variable_any
typically has a more complex implementation than condition_variable
.
condition_variable()
~condition_variable()
void notify_one()
void notify_all()
void wait(boost::unique_lock<boost::mutex>& lock)
template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>&
lock,
predicate_type pred)
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time
const&
abs_time)
template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>&
lock,duration_type const& rel_time)
template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>&
lock,
boost::system_time const& abs_time, predicate_type
pred)
template <class Clock, class Duration>
cv_status wait_until(boost::unique_lock<boost::mutex>& lock, const chrono::time_point<Clock, Duration>&
abs_time)
template <class Rep, class Period>
cv_status wait_for(boost::unique_lock<boost::mutex>& lock, const chrono::duration<Rep, Period>&
rel_time)
template <class Clock, class Duration, class Predicate> bool wait_until(boost::unique_lock<boost::mutex>&
lock,
const chrono::time_point<Clock, Duration>& abs_time, Predicate
pred)
template <class Rep, class Period, class Predicate> bool wait_for(boost::unique_lock<boost::mutex>&
lock,
const chrono::duration<Rep, Period>& rel_time, Predicate
pred)
//#include <boost/thread/condition_variable.hpp> namespace boost { class condition_variable { public: condition_variable(); ~condition_variable(); void notify_one() noexcept; void notify_all() noexcept; void wait(boost::unique_lock<boost::mutex>& lock); template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>& lock,predicate_type predicate); template <class Clock, class Duration> typename cv_status::type wait_until( unique_lock<mutex>& lock, const chrono::time_point<Clock, Duration>& t); template <class Clock, class Duration, class Predicate> bool wait_until( unique_lock<mutex>& lock, const chrono::time_point<Clock, Duration>& t, Predicate pred); template <class Rep, class Period> typename cv_status::type wait_for( unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& d); template <class Rep, class Period, class Predicate> bool wait_for( unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& d, Predicate pred); #if defined BOOST_THREAD_USES_DATETIME bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time); template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time); template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate); template<typename duration_type,typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate); bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time); template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate); #endif }; }
Constructs an object of class condition_variable
.
boost::thread_resource_error
if an error
occurs.
All threads waiting on *this
have been notified by a call
to notify_one
or
notify_all
(though
the respective calls to wait
or timed_wait
need
not have returned).
Destroys the object.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks one of those threads.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks all of those threads.
Nothing.
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
timed_wait
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
As-if
while(!pred()) { wait(lock); }
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
timed_wait
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by boost::get_system_time()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
false
if the call
is returning because the time specified by abs_time
was reached, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
timed_wait
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
false
if the call
is returning because the time period specified by rel_time
has elapsed, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
![]() |
Note |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred()) { if(!timed_wait(lock,abs_time)) { return pred(); } } return true;
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
wait_for
or wait_until
in all the threads
currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by Clock::now()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
cv_status::timeout
if the call is returning
because the time specified by abs_time
was reached, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
wait_until
or
wait_for
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
cv_status::timeout
if the call is returning
because the time period specified by rel_time
has elapsed, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
![]() |
Note |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred()) { if(!wait_until(lock,abs_time)) { return pred(); } } return true;
As-if
return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
condition_variable_any()
~condition_variable_any()
void notify_one()
void notify_all()
template<typename lock_type> void wait(lock_type&
lock)
template<typename lock_type,typename predicate_type>
void wait(lock_type& lock, predicate_type
pred)
template<typename lock_type> bool timed_wait(lock_type&
lock,boost::system_time const& abs_time)
template<typename lock_type,typename duration_type>
bool timed_wait(lock_type& lock,duration_type
const&
rel_time)
template<typename lock_type,typename predicate_type>
bool timed_wait(lock_type& lock, boost::system_time
const&
abs_time,
predicate_type pred)
template <class lock_type, class Clock, class Duration> cv_status
wait_until(lock_type&
lock,
const chrono::time_point<Clock, Duration>& abs_time)
template <class lock_type, class Rep, class Period> cv_status
wait_for(lock_type&
lock,
const chrono::duration<Rep, Period>& rel_time)
template <class lock_type, class Clock, class Duration, class Predicate>
bool wait_until(lock_type& lock, const chrono::time_point<Clock, Duration>&
abs_time,
Predicate pred)
template <class lock_type, class Rep, class Period, class Predicate>
bool wait_for(lock_type& lock, const chrono::duration<Rep, Period>&
rel_time,
Predicate pred)
//#include <boost/thread/condition_variable.hpp> namespace boost { class condition_variable_any { public: condition_variable_any(); ~condition_variable_any(); void notify_one(); void notify_all(); template<typename lock_type> void wait(lock_type& lock); template<typename lock_type,typename predicate_type> void wait(lock_type& lock,predicate_type predicate); template <class lock_type, class Clock, class Duration> cv_status wait_until( lock_type& lock, const chrono::time_point<Clock, Duration>& t); template <class lock_type, class Clock, class Duration, class Predicate> bool wait_until( lock_type& lock, const chrono::time_point<Clock, Duration>& t, Predicate pred); template <class lock_type, class Rep, class Period> cv_status wait_for( lock_type& lock, const chrono::duration<Rep, Period>& d); template <class lock_type, class Rep, class Period, class Predicate> bool wait_for( lock_type& lock, const chrono::duration<Rep, Period>& d, Predicate pred); #if defined BOOST_THREAD_USES_DATETIME template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time); template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time); template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate); template<typename lock_type,typename duration_type,typename predicate_type> bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate); template<typename lock_type> bool timed_wait(lock_type>& lock,boost::xtime const& abs_time); template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate); #endif }; }
Constructs an object of class condition_variable_any
.
boost::thread_resource_error
if an error
occurs.
All threads waiting on *this
have been notified by a call
to notify_one
or
notify_all
(though
the respective calls to wait
or timed_wait
need
not have returned).
Destroys the object.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks one of those threads.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks all of those threads.
Nothing.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
As-if
while(!pred()) { wait(lock); }
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by boost::get_system_time()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
false
if the call
is returning because the time specified by abs_time
was reached, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
false
if the call
is returning because the time period specified by rel_time
has elapsed, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
![]() |
Note |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred()) { if(!timed_wait(lock,abs_time)) { return pred(); } } return true;
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by Clock::now()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
cv_status::timeout
if the call is returning
because the time specified by abs_time
was reached, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
cv_status::timeout
if the call is returning
because the time specified by abs_time
was reached, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
![]() |
Note |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred())
{
if(!wait_until
(lock,abs_time))
{
return pred();
}
}
return true;
As-if
return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
// #include <boost/thread/condition.hpp> namespace boost { typedef condition_variable_any condition; }
The typedef condition
is
provided for backwards compatibility with previous boost releases.
// #include <boost/thread/condition_variable.hpp> namespace boost { void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); }
lk
is locked by the
calling thread and either no other thread is waiting on cond
, or lk.mutex()
returns the same value for each
of the lock arguments supplied by all concurrently waiting (via
wait
, wait_for
, or wait_until
)
threads.
transfers ownership of the lock associated with lk
into internal storage and schedules cond
to be notified when the current thread exits, after all objects of
thread storage duration associated with the current thread have been
destroyed. This notification shall be as if
lk.unlock(); cond.notify_all();