c++11 线程支持库----条件变量

最新推荐文章于 2023-06-15 17:21:45 发布

沧浪之水清兮

最新推荐文章于 2023-06-15 17:21:45 发布

阅读量441

点赞数

分类专栏： C++11 并发编程

C++11 并发编程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细介绍了C++11线程库中的条件变量`std::condition_variable`，包括`notify_one`、`notify_all`、`wait`、`wait_for`和`wait_until`的使用方法和注意事项。强调了在修改共享变量时必须持有互斥锁，并解释了等待线程被唤醒后需要检查条件再决定是否继续等待的重要性。

摘要由CSDN通过智能技术生成

std::condition_variable

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

有意修改变量的线程必须

获得 std::mutex （典型地通过 std::unique_lock ）
在保有锁时进行修改
在 std::condition_variable 上执行 notify_one 或 notify_all （不需要为通知保有锁）

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

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

获得 std::unique_lock<std::mutex> ，在与用于保护共享变量者相同的互斥上
执行 wait 、 wait_for 或 wait_until ，等待操作自动释放互斥，并悬挂线程的执行。
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) 。

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
 
/* 与 std::mutex 组合使用 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

通知：

std::condition_variable::notify_one

void notify_one() noexcept;

若任何线程在 *this 上等待，则调用 notify_one 会解阻塞等待线程之一。

注意

notify_one()/notify_all() 的效果与 wait()/wait_for()/wait_until() 的三个原子部分的每一者（解锁+等待、唤醒和锁定）以能看做原子变量修改顺序单独全序发生：顺序对此单独的 condition_variable 是特定的。譬如，这使得 notify_one() 不可能被延迟并解锁正好在进行 notify_one() 调用后开始等待的线程。

通知线程不必保有等待线程所保有的同一互斥上的锁；实际上这么做是劣化，因为被通知线程将立即再次阻塞，等待通知线程释放锁。然而一些实现（尤其是许多 pthread 的实现）辨识此情形，在通知调用中，直接从条件变量队列转移等待线程到互斥队列，而不唤醒它，以避免此“急促并等待”场景。

然而，在要求精确调度事件时，可能必须在处于锁下时通知，例如，在若满足条件则线程将退出程序，导致析构通知线程的 condition_variable 的情况下。互斥解锁之后，但在通知前的虚假唤醒可能导致通知在被销毁对象上调用。

#include <iostream>
#include <condition_variable>
#include <thread>
#include <chrono>
 
std::condition_variable cv;
std::mutex cv_m;
int i = 0;
bool done = false;
 
void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cout << "Waiting... \n";
    cv.wait(lk, []{return i == 1;});
    std::cout << "...finished waiting. i == 1\n";
    done = true;
}
 
void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Notifying falsely...\n";
    cv.notify_one(); // 等待线程被通知 i == 0.
                     // cv.wait 唤醒，检查 i ，再回到等待
 
    std::unique_lock<std::mutex> lk(cv_m);
    i = 1;
    while (!done) 
    {
        std::cout << "Notifying true change...\n";
        lk.unlock();
        cv.notify_one(); // 等待线程被通知 i == 1 ， cv.wait 返回
        std::this_thread::sleep_for(std::chrono::seconds(1));
        lk.lock();
    }
}
 
int main()
{
    std::thread t1(waits), t2(signals);
    t1.join(); 
    t2.join();
}

//可能的输出：

Waiting... 
Notifying falsely...
Notifying true change...
...finished waiting. i == 1

std::condition_variable::notify_all

void notify_all() noexcept; //解阻塞全部当前等待于 *this 的线程。

注意

通知线程不必保有与等待线程所保有者相同互斥的锁；实际上这么做是劣化，因为被通知线程将立即再次阻塞，以等待通知线程释放锁。

#include <iostream>
#include <condition_variable>
#include <thread>
#include <chrono>
 
std::condition_variable cv;
std::mutex cv_m; // 此互斥用于三个目的：
                 // 1) 同步到 i 的访问
                 // 2) 同步到 std::cerr 的访问
                 // 3) 为条件变量 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

等待：

std::condition_variable::wait

void wait( std::unique_lock<std::mutex>& lock );

template< class Predicate >
void wait( std::unique_lock<std::mutex>& lock, Predicate pred );

wait 导致当前线程阻塞直至条件变量被通知，或虚假唤醒发生，可选地循环直至满足某谓词。

1) 原子地释放 lock ，阻塞当前执行线程，并将它添加到于 *this 上等待的线程列表。线程将在执行 notify_all() 或 notify_one() 时被解除阻塞。解阻塞时，无关乎原因， lock 得到释放且 wait 退出。若此函数通过异常退出，则亦会重获得 lock 。 (C++14 前)

2) 等价于

while (!pred()) {
    wait(lock);
}

此重载可用于在等待特定条件成为 true 时忽略虚假唤醒。注意进入此方法前，必须得到 lock ， wait(lock) 退出后也会重获得它，即 lock 能用做 pred() 访问的保障。

若这些函数不能满足后置条件（ lock.owns_lock()==true 且调用方线程锁定 lock.mutex() ），则调用 std::terminate 。例如，这可能在重锁定互斥抛异常的情况下发生。

注意

若当前线程未锁定 lock.mutex() ，则调用此函数是未定义行为。

若 lock.mutex() 与所有其他当前等待在同一条件变量上的线程所用的互斥不相同，则调用此函数是未定义行为。

std::condition_variable::wait_for

template< class Rep, class Period >

std::cv_status wait_for( std::unique_lock<std::mutex>& lock,

const std::chrono::duration<Rep, Period>& rel_time);

template< class Rep, class Period, class Predicate >

bool wait_for( std::unique_lock<std::mutex>& lock,
const std::chrono::duration<Rep, Period>& rel_time,

Predicate pred);

1) 原子地释放 lock ，阻塞当前线程，并将它添加到等待在 *this 上的线程列表。线程将在执行 notify_all() 或 notify_one() 时，或度过相对时限 rel_time 时被解除阻塞。它亦可被虚假地解除阻塞。解阻塞时，无关缘由，重获得 lock 并退出 wait_for() 退出。若此函数通过异常退出，则亦重获得 lock 。 (C++14 前)

2) 等价于 return wait_until(lock, std::chrono::steady_clock::now() + rel_time, std::move(pred));。此重载可用于忽略虚假唤醒。

用稳定时钟度量时长。由于调度或资源争议，此函数可能阻塞长于 timeout_duration 。

若当前线程未锁定 lock.mutex() ，则调用此函数是未定义行为。

若 lock.mutex() 与所有其他当前等待在同一条件变量上的线程所用的互斥不相同，则调用此函数是未定义行为。

#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>
//using namespace  std::chrono_literals;

std::condition_variable cv;
std::mutex cv_m;
int i;

void waits(int idx)
{
	std::unique_lock<std::mutex> lk(cv_m);
	if (cv.wait_for(lk, idx * std::chrono::milliseconds(100), []{return i == 1; }))
		std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n';
	else
		std::cerr << "Thread " << idx << " timed out. i == " << i << '\n';
}

void signals()
{
	std::this_thread::sleep_for(std::chrono::milliseconds(120));
	std::cerr << "Notifying...\n";
	cv.notify_all();
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	{
		std::lock_guard<std::mutex> lk(cv_m);
		i = 1;
	}
	std::cerr << "Notifying again...\n";
	cv.notify_all();
}

int main()
{
	std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals);
	t1.join(); t2.join(), t3.join(), t4.join();
}


//输出：

Thread 1 timed out. i == 0
Notifying...
Thread 2 timed out. i == 0
Notifying again...
Thread 3 finished waiting. i == 1

std::condition_variable::wait_until

template< class Clock, class Duration >

std::cv_status wait_until( std::unique_lock<std::mutex>& lock,

const std::chrono::time_point<Clock, Duration>& timeout_time );

template< class Clock, class Duration, class Predicate >

bool wait_until( std::unique_lock<std::mutex>& lock,
const std::chrono::time_point<Clock, Duration>& timeout_time, Predicate pred );

wait_until 导致当前线程阻塞直至通知条件变量、抵达指定时间或虚假唤醒发生，可选的循环直至满足某谓词。

1) 原子地释放 lock ，阻塞当前线程，并将它添加到等待在 *this 上的线程列表。线程将在执行 notify_all() 或 notify_one() 时，或抵达绝对时间点 timeout_time 时被解除阻塞。它亦可被虚假地解除阻塞。解除阻塞时，无关缘由，重获得 lock 并退出 wait_for() 。若此函数通过异常退出，则亦重获得 lock 。 (C++14 前)

2) 等价于

while (!pred()) {
    if (wait_until(lock, timeout_time) == std::cv_status::timeout) {
        return pred();
    }
}
return true;

注意

使用倾向 timeout_time 的时钟，不要求是单调时钟。若不连续地调节时钟，则不对此函数的行为保证，但既存实现将 timeout_time 从 Clock 转换到 std::chrono::system_clock ，并委托 POSIX pthread_cond_timedwait 以令等待忠实于系统时钟，但非用户提供 Clock 的调节。任何情况下，由于调度或资源争议延迟，函数可能等待长于抵达 timeout_time 。

即使使用的始终是 std::chrono::steady_clock 或另一单调时钟，系统时钟调节亦可能导致虚假唤醒。

#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>

std::condition_variable cv;
std::mutex cv_m;
std::atomic<int> i{ 0 };

void waits(int idx)
{
	std::unique_lock<std::mutex> lk(cv_m);
	auto now = std::chrono::system_clock::now();
	if (cv.wait_until(lk, now + idx * std::chrono::milliseconds(100), [](){return i == 1; }))
		std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n';
	else
		std::cerr << "Thread " << idx << " timed out. i == " << i << '\n';
}

void signals()
{
	std::this_thread::sleep_for(std::chrono::milliseconds(120));
	std::cerr << "Notifying...\n";
	cv.notify_all();
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	i = 1;
	std::cerr << "Notifying again...\n";
	cv.notify_all();
}

int main()
{
	std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals);
	t1.join();
	t2.join();
	t3.join();
	t4.join();
}

std::condition_variable_any

condition_variable_any 类是 std::condition_variable 的泛化。相对于只在 std::unique_lock<std::mutex> 上工作的 std::condition_variable ， condition_variable_any 能在任何满足基础可锁 (BasicLockable) 要求的锁上工作。

条件变量语义描述见 std::condition_variable 。

类 std::condition_variable_any 是标准布局类。它不可复制构造、移动构造、复制赋值或移动赋值。

若锁是 std::unique_lock ，则 std::condition_variable 可能提供更好的性能。

成员函数

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

沧浪之水清兮

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
c++11 线程支持库----条件变量

std::condition_variablecondition_variable 类是同步原语，能用于阻塞一个线程，或同时阻塞多个线程，直至另一线程修改共享变量（条件）并通知 condition_variable 。有意修改变量的线程必须获得 std::mutex （典型地通过 std::unique_lock ）在保有锁时进行修改在 std::condition_varia...
复制链接

扫一扫

专栏目录