命名空间
变体
操作

std::condition_variable::wait

来自 cppreference.cn
 
 
并发支持库
线程
(C++11)
(C++20)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
协同取消
互斥
通用锁管理
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
条件变量
(C++11)
信号量
门闩和屏障
(C++20)
(C++20)
期值
(C++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
危险指针
原子类型
(C++11)
(C++20)
原子类型的初始化
(C++11)(C++20 中已弃用)
(C++11)(C++20 中已弃用)
内存排序
(C++11)(C++26 中已弃用)
原子操作的自由函数
原子标志的自由函数
 
 
void wait( std::unique_lock<std::mutex>& lock );
(1) (C++11 起)
template< class Predicate >
void wait( std::unique_lock<std::mutex>& lock, Predicate pred );
(2) (C++11 起)

wait 导致当前线程阻塞,直到条件变量被通知,或出现虚假唤醒。可以任选提供 pred 以检测虚假唤醒。

1) 原子地调用 lock.unlock() 并阻塞于 *this
notify_all()notify_one() 被执行时,线程将被解除阻塞。它也可能被虚假地解除阻塞。
当解除阻塞时,调用 lock.lock()(可能会在该锁上阻塞),然后返回。
2) 等价于
while (!pred())
    wait(lock);
该重载可用于在等待特定条件变为true时忽略虚假唤醒。

wait 返回后,lock.owns_lock()true,且 lock.mutex() 被调用线程锁定。如果这些后置条件无法被满足[1],则调用 std::terminate

如果满足以下任何条件,则行为是未定义的:

  • lock.owns_lock()false
  • lock.mutex() 未被调用线程锁定。
  • 如果其他一些线程也在等待 *this,那么 lock.mutex() 不同于那些线程在 *this 上调用的等待函数(waitwait_forwait_until)所解锁的互斥体。
  1. 这可能发生于对互斥体重新加锁时抛出异常。

目录

[编辑] 参数

- 一个必须被调用线程锁定的锁
pred - 用于检查是否可以完成等待的谓词
类型要求
-
Predicate 必须满足函数对象 (FunctionObject) 的要求。
-
pred() 必须是有效表达式,其类型和值类别必须满足可布尔测试 (BooleanTestable) 的要求。

[编辑] 异常

1) 不抛出任何异常。
2) pred 抛出的任何异常。

[编辑] 注意

notify_one()/notify_all() 的效果和 wait()/wait_for()/wait_until() 的三个原子部分(解锁+等待、唤醒、加锁)中的每一个,都发生于一个单独的全序中,该顺序可被看作一个原子变量的修改顺序:此顺序是该单独的条件变量所特有的。这使得 notify_one() 不可能被延迟,然后解除阻塞一个在 notify_one() 调用刚作出后开始等待的线程。

[编辑] 示例

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <thread>
 
std::condition_variable cv;
std::mutex cv_m; // This mutex is used for three purposes:
                 // 1) to synchronize accesses to i
                 // 2) to synchronize accesses to std::cerr
                 // 3) for the condition variable cv
int i = 0;
 
void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "Waiting... \n";
    cv.wait(lk, []{ return i == 1; });
    std::cerr << "...finished waiting. i == 1\n";
}
 
void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notifying...\n";
    }
    cv.notify_all();
 
    std::this_thread::sleep_for(std::chrono::seconds(1));
 
    {
        std::lock_guard<std::mutex> lk(cv_m);
        i = 1;
        std::cerr << "Notifying again...\n";
    }
    cv.notify_all();
}
 
int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

可能的输出

Waiting...
Waiting...
Waiting...
Notifying...
Notifying again...
...finished waiting. i == 1
...finished waiting. i == 1
...finished waiting. i == 1

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 发布时的行为 正确的行为
LWG 2114
(P2167R3)
C++11 可转换为 bool 对于反映实现的期望来说太弱了 要求已加强
LWG 2135 C++11 如果 lock.lock() 抛出异常,则行为不明确 在这种情况下调用 std::terminate

[编辑] 参阅

阻塞当前线程,直到条件变量被唤醒或达到指定的超时时长。
(公开成员函数) [编辑]
阻塞当前线程,直到条件变量被唤醒或达到指定的时间点。
(公开成员函数) [编辑]
C 语言文档中关于cnd_wait的内容

[编辑] 外部链接

The Old New Thing 文章:Win32 条件变量中的虚假唤醒。