命名空间
变体
动作

std::condition_variable::wait

来自 cppreference.com
 
 
并发支持库
线程
(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++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 中已弃用)
内存排序
原子操作的自由函数
原子标志的自由函数
 
 
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() 不同于等待函数(waitwait_forwait_until)在 *this 上调用的 mutex 解锁。
  1. 如果 mutex 的重新锁定抛出异常,则可能会发生这种情况。

内容

[edit] 参数

lock - 调用线程必须锁定的 lock
pred - 用于检查是否可以完成等待的谓词
类型要求
-
Predicate 必须满足 FunctionObject 的要求。
-
pred() 必须是一个有效的表达式,并且它的类型和值类别必须满足 BooleanTestable 的要求。

[edit] 异常

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

[edit] 注释

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++ 标准。

DR 应用于 发布的行为 正确行为
LWG 2114
(P2167R3)
C++11 转换为 bool 太弱,无法反映实现的预期 要求得到加强
LWG 2135 C++11 如果 lock.lock() 抛出异常,行为不明确 在这种情况下调用 std::terminate

[编辑] 参见

阻塞当前线程,直到条件变量被唤醒或在指定的超时时间之后
(公共成员函数) [编辑]
阻塞当前线程,直到条件变量被唤醒或达到指定的时间点
(公共成员函数) [编辑]
C 文档 用于 cnd_wait

[编辑] 外部链接

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