通过

condition_variable 类

  • 项目

使用 condition_variable 类在具有 mutex 类型的 unique_lock<mutex> 时等待事件。 此类型的对象的性能可能比 condition_variable_any<unique_lock<mutex>> 类型的对象更好。

语法

class condition_variable;

成员

构造函数

名称 描述
condition_variable 构造 condition_variable 对象。

函数

名称 描述
native_handle 返回表示 condition_variable 句柄的特定于实现的类型。
notify_all 取消阻止正在等待 condition_variable 对象的所有线程。
notify_one 取消阻止正在等待 condition_variable 对象的某个线程。
wait 阻止线程。
wait_for 阻止某个线程，并设置线程阻止的时间间隔。
wait_until 阻止某个线程，并设置线程阻止的最大时间点。

condition_variable

构造 condition_variable 对象。

condition_variable();

备注

如果没有足够的内存，构造函数将抛出包含 not_enough_memory 错误代码的 system_error 对象。 如果由于某些其他资源不可用导致无法构造该对象，则构造函数将抛出包含 resource_unavailable_try_again 错误代码的 system_error 对象。

native_handle

返回表示 condition_variable 句柄的特定于实现的类型。

native_handle_type native_handle();

返回值

native_handle_type 被定义为指向并发运行时内部数据结构的指针。

notify_all

取消阻止正在等待 condition_variable 对象的所有线程。

void notify_all() noexcept;

notify_one

取消阻止正在 condition_variable 对象上等待的某个线程。

void notify_one() noexcept;

wait

阻止线程。

void wait(unique_lock<mutex>& Lck);

template <class Predicate>
void wait(unique_lock<mutex>& Lck, Predicate Pred);

参数

Lck
unique_lock<mutex> 对象。

Pred
返回 true 或 false 的任何表达式。

备注

第一种方法进行阻止，直到通过调用 notify_one 或 notify_all 对 condition_variable 对象发出信号。 它还可错误唤醒。

第二种方法实际上执行以下代码。

while(!Pred())
    wait(Lck);

wait_for

阻止某个线程，并设置线程阻止的时间间隔。

template <class Rep, class Period>
cv_status wait_for(
    unique_lock<mutex>& Lck,
    const chrono::duration<Rep, Period>& Rel_time);

template <class Rep, class Period, class Predicate>
bool wait_for(
    unique_lock<mutex>& Lck,
    const chrono::duration<Rep, Period>& Rel_time,
    Predicate Pred);

参数

Lck
unique_lock<mutex> 对象。

Rel_time
chrono::duration 对象指定线程唤醒前的时间。

Pred
返回 true 或 false 的任何表达式。

返回值

如果在已用 Rel_time 时间时等待终止，则第一种方法返回 cv_status::timeout。 否则，该方法将返回 cv_status::no_timeout。

第二种方法返回值 Pred。

注解

第一种方法进行阻止，直到通过调用 notify_one 或 notify_all 对 condition_variable 对象发出信号，或直到已用 Rel_time 时间间隔。 它还可错误唤醒。

第二种方法实际上执行以下代码。

while(!Pred())
    if(wait_for(Lck, Rel_time) == cv_status::timeout)
    return Pred();

return true;

wait_until

阻止某个线程，并设置线程阻止的最大时间点。

template <class Clock, class Duration>
cv_status wait_until(
    unique_lock<mutex>& Lck,
    const chrono::time_point<Clock, Duration>& Abs_time);

template <class Clock, class Duration, class Predicate>
bool wait_until(
    unique_lock<mutex>& Lck,
    const chrono::time_point<Clock, Duration>& Abs_time,
    Predicate Pred);

cv_status wait_until(
    unique_lock<mutex>& Lck,
    const xtime* Abs_time);

template <class Predicate>
bool wait_until(
    unique_lock<mutex>& Lck,
    const xtime* Abs_time,
    Predicate Pred);

参数

Lck
unique_lock<mutex> 对象。

Abs_time
chrono::time_point 对象。

Pred
返回 true 或 false 的任何表达式。

返回值

如果在已用 Abs_time 时间时等待终止，则返回 cv_status 类型的方法返回 cv_status::timeout。 否则，方法返回 cv_status::no_timeout。

返回 bool 的方法返回值 Pred。

备注

第一种方法进行阻止，直到通过调用 notify_one 或 notify_all 对 condition_variable 对象发出信号，或直到 Abs_time。 它还可错误唤醒。

第二种方法实际上执行以下代码

while(!Pred())
    if(wait_until(Lck, Abs_time) == cv_status::timeout)
    return Pred();

return true;

第三种和第四种方法使用指向 xtime 类型的对象的指针来替换 chrono::time_point 对象。 xtime 对象指定等待信号的最大时间。

另请参阅

头文件引用
<condition_variable>