c++11 多线程支持 条件变量（condition_variable）（三）
定义于头文件 <condition_variable>
条件变量是允许多个线程相互交流的同步原语。它允许一定量的线程等待（可以定时）另一线程的提醒，然后再继续。条件变量始终关联到一个互斥。
阻塞当前线程，直到条件变量被唤醒
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 导致当前线程阻塞直至条件变量被通知，或虚假唤醒发生，可选地循环直至满足某谓词。
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 。例如，这可能在重锁定互斥抛异常的情况下发生。 | (C++14 起) |
参数
| lock | - | std::unique_lock<std::mutex> 类型对象，必须为当前线程所锁定 |
| pred | - | 等待是否应该持续则返回 false 的谓词。 谓词函数的签名应等价于如下者： bool pred(); |
返回值
（无）
异常
1)
| 可能抛出 std::system_error ，亦可能传播 lock.lock() 或 lock.unlock() 所抛的异常。 | (C++14 前) |
| 不抛出 | (C++14 起) |
2) 同 (1) 但亦会传播 pred 所抛的异常
注意
若当前线程未锁定 lock.mutex() ，则调用此函数是未定义行为。
若 lock.mutex() 与所有其他当前等待在同一条件变量上的线程所用的互斥不相同，则调用此函数是未定义行为。
notify_one()/notify_all() 的效果与 wait()/wait_for()/wait_until() 的三个原子部分的每一者（解锁+等待、唤醒和锁定）以能看做原子变量修改顺序单独全序发生：顺序对此单独的 condition_variable 是特定的。譬如，这使得 notify_one() 不可能被延迟并解锁正好在进行 notify_one() 调用后开始等待的线程。
调用示例
#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();
}输出
阻塞当前线程，直到条件变量被唤醒，或到指定时限时长后
template< class Rep, class Period >
std::cv_status wait_for( std::unique_lock<std::mutex>& lock,
const std::chrono::duration<Rep, Period>& rel_time); (1) (C++11起)
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); (2) (C++11 起)
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() 与所有其他当前等待在同一条件变量上的线程所用的互斥不相同，则调用此函数是未定义行为。
| 若这些函数不能满足后置条件（ lock.owns_lock()==true 且调用方线程锁定 lock.mutex() ），则调用 std::terminate 。例如，这可能在重锁定互斥抛异常的情况下发生。 | (C++14 起) |
参数
| lock | - | std::unique_lock<std::mutex> 类型对象，必须被当前线程锁定 |
| rel_time | - | 表示等待所耗的最大时间的 std::chrono::duration 类型对象。注意 rel_time 必须足够小，以在加到 std::chrono::steady_clock::now() 时不溢出。 |
| pred | - | 是否应该持续等待则返回 false 的谓词。 谓词函数的签名应等价于如下者： bool pred(); |
返回值
1) 若经过 rel_time 所指定的关联时限则为 std::cv_status::timeout ，否则为 std::cv_status::no_timeout 。
2) 若经过 rel_time 时限后谓词 pred 仍求值为 false 则为 false ，否则为 true 。
异常
1)
| 可能抛出 std::system_error ，亦可能传播 lock.lock() 或 lock.unlock() 所抛的异常 | (C++14 前) |
| 执行期间时钟、时间点或时长可能抛出的任何异常（标准库提供的时钟、时间点和时长决不抛出） | (C++14 起) |
2) 同 (1) ，但亦可传播 pred 所抛的异常
注意
即使在锁下通知，重载 (1) 在因时限退出时也不对关联谓词的状态做出保证。
notify_one()/notify_all() 的效果与 wait()/wait_for()/wait_until() 的三个原子部分的每一者（解锁+等待、唤醒和锁定）以能看做原子变量修改顺序单独全序发生：顺序对此单独的 condition_variable 是特定的。譬如，这使得 notify_one() 不可能被延迟并解锁正好在进行 notify_one() 调用后开始等待的线程。
调用示例
#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>
using namespace std::chrono;
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, milliseconds(idx * 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(milliseconds(120));
std::cerr << "Notifying...\n";
cv.notify_all();
std::this_thread::sleep_for(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();
}输出
阻塞当前线程，直到条件变量被唤醒，或直到抵达指定时间点
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 ); (1) (C++11 起)
template< class Clock, class Duration, class Pred >
bool wait_until( std::unique_lock<std::mutex>& lock,
const std::chrono::time_point<Clock,
Duration>& timeout_time, Pred pred ); (2) (C++11 起)
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;
此重载可用于忽略虚假唤醒。
若当前线程未锁定 lock.mutex() ，则调用此函数是未定义行为。
若 lock.mutex() 与所有其他当前等待在同一条件变量上的线程所用的互斥不相同，则调用此函数是未定义行为。
| 若这些函数不能满足后置条件（ lock.owns_lock()==true 且调用方线程锁定 lock.mutex() ），则调用 std::terminate 。例如，这可能在重锁定互斥抛异常的情况下发生。 | (C++14 起) |
参数
| lock | - | std::unique_lock<std::mutex> 类型对象，必须被当前线程锁定 |
| timeout_time | - | 表示停止等待时间的 std::chrono::time_point 类型对象 |
| pred | - | 是否应该持续等待则返回 false 的谓词。 谓词函数的签名应等价于如下者： bool pred(); |
返回值
1) 若抵达 timeout_time 指定的的绝对时间点则为 std::cv_status::timeout ，否则为 std::cv_status::no_timeout 。
2) 若度过 timeout_time 时限后 pred 仍求值为 false 则为 false ，否则为 true 。若已度过时限，则求值并返回 pred 的结果。
异常
1)
| 可抛出 std::system_error ，亦可传播 lock.lock() 或 lock.unlock() 所抛的异常 | (C++14 前) |
| 执行期间时钟、时间点或时长可能抛出的任何异常（标准库提供的时钟、时间点和时长决不抛出） | (C++14 起) |
2) 同 (1) ，但亦可传播 pred 所抛的异常
注意
使用倾向 timeout_time 的时钟，不要求是单调时钟。若不连续地调节时钟，则不对此函数的行为保证，但既存实现将 timeout_time 从 Clock 转换到 std::chrono::system_clock ，并委托 POSIX pthread_cond_timedwait 以令等待忠实于系统时钟，但非用户提供 Clock 的调节。任何情况下，由于调度或资源争议延迟，函数可能等待长于抵达 timeout_time 。
即使使用的始终是 std::chrono::steady_clock 或另一单调时钟，系统时钟调节亦可能导致虚假唤醒。
notify_one()/notify_all() 的效果与 wait()/wait_for()/wait_until() 的三个原子部分的每一者（解锁+等待、唤醒和锁定）以能看做原子变量修改顺序单独全序发生：顺序对此单独的 condition_variable 是特定的。譬如，这使得 notify_one() 不可能被延迟并解锁正好在进行 notify_one() 调用后开始等待的线程。
调用示例
#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>
using namespace std::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();
auto func = []()
{
return i == 1;
};
if (cv.wait_until(lk, now + milliseconds(idx * 100), func))
{
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(milliseconds(120));
std::cerr << "Notifying...\n";
cv.notify_all();
std::this_thread::sleep_for(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();
}输出
更多推荐
1
0- 0
已为社区贡献3条内容
所有评论(0)