std::condition_variable

来自cppreference.com
< cpp‎ | thread
 
 
线程支持库
线程
(C++11)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
互斥
(C++11)
通用锁管理
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
条件变量
condition_variable
(C++11)
(C++11)
期货
(C++11)
(C++11)
(C++11)
(C++11)
 
 
定义于头文件 <condition_variable>
class condition_variable;
(C++11 起)

condition_variable 类是同步原语,能用于阻塞一个线程,或同时阻塞多个线程,直至另一线程修改共享变量(条件)并通知 condition_variable

有意修改变量的线程必须

  1. 获得 std::mutex (典型地通过 std::lock_guard
  2. 在保有锁时进行修改
  3. std::condition_variable 上执行 notify_onenotify_all (不需要为通知保有锁)

即使共享变量是原子的,也必须在互斥下修改它,以正确地发布修改到等待的线程。

任何有意在 std::condition_variable 上等待的线程必须

  1. 获得 std::unique_lock<std::mutex> ,在与用于保护共享变量者相同的互斥上
  2. 执行 waitwait_forwait_until ,等待操作自动释放互斥,并悬挂线程的执行。
  3. condition_variable 被通知时,时限消失或虚假唤醒发生,线程被唤醒,且自动重获得互斥。之后线程应检查条件,若唤醒是虚假的,则继续等待。

std::condition_variable 只可与 std::unique_lock<std::mutex> 一同使用;此限制在一些平台上允许最大效率。 std::condition_variable_any 提供可与任何基础可锁 (BasicLockable) 对象,例如 std::shared_lock 一同使用的条件变量。

condition_variable 容许 waitwait_forwait_untilnotify_onenotify_all 成员函数的同时调用。

std::condition_variable标准布局类型 (StandardLayoutType) 。它不可复制构造 (CopyConstructible) 、可移动构造 (MoveConstructible) 、可复制赋值 (CopyAssignable) 、可移动赋值 (MoveAssignable) 。

目录

[编辑] 成员类型

成员类型 定义
native_handle_type 实现定义

[编辑] 成员函数

构造对象
(公开成员函数) [编辑]
析构对象
(公开成员函数) [编辑]
operator=
[删除]
不可复制赋值
(公开成员函数) [编辑]
通知
通知一个等待的线程
(公开成员函数) [编辑]
通知所有等待的线程
(公开成员函数) [编辑]
等待
阻塞当前线程,直到条件变量被唤醒
(公开成员函数) [编辑]
阻塞当前线程,直到条件变量被唤醒,或到指定时限时长后
(公开成员函数) [编辑]
阻塞当前线程,直到条件变量被唤醒,或直到抵达指定时间点
(公开成员函数) [编辑]
原生句柄
返回原生句柄
(公开成员函数) [编辑]

[编辑] 示例

std::mutex 组合使用 condition_variable ,以促进线程间交流。

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
 
std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;
 
void worker_thread()
{
    // 等待直至 main() 发送数据
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, []{return ready;});
 
    // 等待后,我们占有锁。
    std::cout << "Worker thread is processing data\n";
    data += " after processing";
 
    // 发送数据回 main()
    processed = true;
    std::cout << "Worker thread signals data processing completed\n";
 
    // 通知前完成手动锁定,以避免等待线程只再阻塞(细节见 notify_one )
    lk.unlock();
    cv.notify_one();
}
 
int main()
{
    std::thread worker(worker_thread);
 
    data = "Example data";
    // 发送数据到 worker 线程
    {
        std::lock_guard<std::mutex> lk(m);
        ready = true;
        std::cout << "main() signals data ready for processing\n";
    }
    cv.notify_one();
 
    // 等候 worker
    {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, []{return processed;});
    }
    std::cout << "Back in main(), data = " << data << '\n';
 
    worker.join();
}

输出:

main() signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in main(), data = Example data after processing