STL线程同步方式：condition_variable 条件变量

云中飞鸿--**峰

已于 2024-09-25 15:07:06 修改

阅读量202

点赞数

CC 4.0 BY-SA版权

分类专栏： # STL标准库文章标签： c++ 开发语言

于 2024-09-25 11:32:38 首次发布

原文链接：https://blog.csdn.net/qq_39277419/article/details/99544724

STL标准库专栏收录该内容

8 篇文章

订阅专栏

条件变量
条件变量是允许多个线程相互交流的同步原语。它允许一定量的线程等待（可以定时）另一线程的提醒，然后再继续。条件变量始终关联到一个互斥。

用到的头文件
<condition_variable>

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

有意修改变量的线程必须（通知线程）

1.获得 std::mutex （典型地通过 std::lock_guard ）
2.在保有锁时进行修改
3.在 std::condition_variable 上执行 notify_one 或 notify_all （不需要为通知保有锁）
即使共享变量是原子的，也必须在互斥下修改它，以正确地发布修改到等待的线程。

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

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

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

condition_variable 容许 wait 、 wait_for 、 wait_until 、 notify_one 及 notify_all 成员函数的同时调用。

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

公共方法

wait

wait(_Lck)
流程图

示例

#include <iostream>
#include <condition_variable>

using namespace std;

mutex wait_mutex;
condition_variable wait_condition_variable;

// 等待线程函数
void wait_thread_func()
{
    unique_lock<mutex> lock(wait_mutex);
    cout << "等待线程(" << this_thread::get_id() << "): 开始等待通知..." << endl;
    wait_condition_variable.wait(lock);
    cout << "等待线程(" << this_thread::get_id() << "): 继续执行代码..." << endl;
}

int main()
{
    thread wait_thread(wait_thread_func);

    this_thread::sleep_for(1s); // 等待1秒后进行通知
    cout << "通知线程(" << this_thread::get_id() << "): 开始通知等待线程..." << endl;
    wait_condition_variable.notify_one();
    wait_thread.join();
    cout << "--- main结束 ---" << endl;
}

Output
等待线程(12348): 开始等待通知…
通知线程(15856): 开始通知等待线程…
等待线程(12348): 继续执行代码…
— main结束 —

错误示例：等待前通知，导致无法获得通知

#include <iostream>
#include <condition_variable>

using namespace std;

mutex wait_mutex;
condition_variable wait_condition_variable;

// 等待线程函数
void wait_thread_func()
{
    this_thread::sleep_for(1s); // 等待1秒后再等待通知
    
    unique_lock<mutex> lock(wait_mutex);
    cout << "等待线程(" << this_thread::get_id() << "): 开始等待通知..." << endl;
    wait_condition_variable.wait(lock);
    cout << "等待线程(" << this_thread::get_id() << "): 继续执行代码..." << endl;
}

int main()
{
    thread wait_thread(wait_thread_func);
    cout << "通知线程(" << this_thread::get_id() << "): 开始通知等待线程..." << endl;
    wait_condition_variable.notify_one();
    wait_thread.join();
    cout << "--- main结束 ---" << endl;
}

Output
通知线程(21892): 开始通知等待线程…
等待线程(2120): 开始等待通知…
(无限等待…)

wait(_Lck, _Pred)
流程图

示例：等待后通知

using namespace std;

mutex wait_mutex;
condition_variable wait_condition_variable;
bool ready = false;

// 等待线程函数
void wait_thread_func()
{
    // 等待通知再继续执行
    unique_lock<mutex> lock(wait_mutex);
    cout << "等待线程(" << this_thread::get_id() << "): 开始等待通知..." << endl;
    wait_condition_variable.wait(lock, [] { return ready; });
    cout << "等待线程(" << this_thread::get_id() << "): 继续执行代码..." << endl;
}

int main()
{
    thread wait_thread(wait_thread_func);

    this_thread::sleep_for(1s); // 等待1秒
    unique_lock<mutex> lock(wait_mutex);
    cout << "通知线程(" << this_thread::get_id() << "): 开始通知等待线程..." << endl;
    ready = true;
    lock.unlock(); // 不解锁的话，等待线程无法获得锁，则会进入死锁
    wait_condition_variable.notify_one();

    wait_thread.join();
    cout << "--- main结束 ---" << endl;
}

Output
等待线程(18172): 开始等待通知…
通知线程(19740): 开始通知等待线程…
等待线程(18172): 继续执行代码…
— main结束

—示例：等待前通知

using namespace std;

mutex wait_mutex;
condition_variable wait_condition_variable;
bool ready = false;

// 等待线程函数
void wait_thread_func()
{
    this_thread::sleep_for(1s); // 等待1秒
    
    // 等待通知再继续执行
    unique_lock<mutex> lock(wait_mutex);
    cout << "等待线程(" << this_thread::get_id() << "): 开始等待通知..." << endl;
    wait_condition_variable.wait(lock, [] { return ready; });
    cout << "等待线程(" << this_thread::get_id() << "): 继续执行代码..." << endl;
}

int main()
{
    thread wait_thread(wait_thread_func);

    unique_lock<mutex> lock(wait_mutex);
    cout << "通知线程(" << this_thread::get_id() << "): 开始通知等待线程..." << endl;
    ready = true;
    lock.unlock(); // 不解锁的话，等待线程无法获得锁，则会进入死锁
    wait_condition_variable.notify_one();

    wait_thread.join();
    cout << "--- main结束 ---" << endl;
}

Output
通知线程(10972): 开始通知等待线程…
等待线程(22632): 开始等待通知…
等待线程(22632): 继续执行代码…
— main结束 —

错误示例：通知线程不加lock可能出现的问题

#include <iostream>
#include <condition_variable>

using namespace std;

mutex wait_mutex;
condition_variable wait_condition_variable;
bool ready = false;

// 等待线程函数
void wait_thread_func()
{
    // 等待通知再继续执行
    unique_lock<mutex> lock(wait_mutex);
    cout << "等待线程(" << this_thread::get_id() << "): 开始等待通知..." << endl;
    wait_condition_variable.wait(lock, []
        {
            bool state = ready;
            cout << "wait执行中(判断条件后,等待通知前)" << endl; // 模拟“wait执行中”
            this_thread::sleep_for(3s);
            return state;
        });
    cout << "等待线程(" << this_thread::get_id() << "): 继续执行代码..." << endl;
}

int main()
{
    thread wait_thread(wait_thread_func);

    this_thread::sleep_for(1s); // 模拟“wait执行中”进行通知

    //unique_lock<mutex> lock(wait_mutex);
    cout << "通知线程(" << this_thread::get_id() << "): 开始通知等待线程..." << endl;
    ready = true;
    //lock.unlock(); // 不解锁的话，等待线程无法获得锁，则会进入死锁
    wait_condition_variable.notify_one();

    wait_thread.join();
    cout << "--- main结束 ---" << endl;
}

Output
等待线程(19732): 开始等待通知…
wait执行中(判断条件后,等待通知前)
通知线程(6408): 开始通知等待线程…
(无限等待…)

解决方案：加入lock

#include <iostream>
#include <condition_variable>

using namespace std;

mutex wait_mutex;
condition_variable wait_condition_variable;
bool ready = false;

// 等待线程函数
void wait_thread_func()
{
    // 等待通知再继续执行
    unique_lock<mutex> lock(wait_mutex);
    cout << "等待线程(" << this_thread::get_id() << "): 开始等待通知..." << endl;
    wait_condition_variable.wait(lock, []
        {
            bool state = ready;
            cout << "wait执行中(判断条件后,等待通知前)" << endl; // 模拟“wait执行中”
            this_thread::sleep_for(3s);
            return state;
        });
    cout << "等待线程(" << this_thread::get_id() << "): 继续执行代码..." << endl;
}

int main()
{
    thread wait_thread(wait_thread_func);

    this_thread::sleep_for(1s); // 模拟“wait执行中”进行通知

    unique_lock<mutex> lock(wait_mutex);
    cout << "通知线程(" << this_thread::get_id() << "): 开始通知等待线程..." << endl;
    ready = true;
    lock.unlock(); // 不解锁的话，等待线程无法获得锁，则会进入死锁
    wait_condition_variable.notify_one();

    wait_thread.join();
    cout << "--- main结束 ---" << endl;
}

Output
等待线程(18072): 开始等待通知…
wait执行中(判断条件后,等待通知前)
通知线程(15672): 开始通知等待线程…
wait执行中(判断条件后,等待通知前)
等待线程(18072): 继续执行代码…
— main结束 —

总结
拥有lock：只会在 “wait执行前/后” 进行通知（通知后"等待线程"可以继续执行）；

没有lock：假如在 “wait执行中(判断条件后,等待通知前)” 进行通知，判断条件为false，并且无法受到通知(造成此次通知无效，“等待线程” 依然处于等待通知状态)；
————————————————

原文链接：https://blog.csdn.net/qq_39277419/article/details/99544724