• c++11 多线程支持 条件变量（condition_variable）（三）

    定义于头文件

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

    阻塞当前线程，直到条件变量被唤醒

    1. void wait( std::unique_lock<std::mutex>& lock );  (1) (C++11 起) 
    2.  
    3. template< class Predicate >
    4. 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 类型对象，必须为当前线程所锁定
    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() 调用后开始等待的线程。

    调用示例

    1. #include <iostream>
    2. #include <condition_variable>
    3. #include <thread>
    4. #include <chrono>
    5.  
    6. std::condition_variable cv;
    7. std::mutex cv_m; // 此互斥用于三个目的：
    8.                  // 1) 同步到 i 的访问
    9.                  // 2) 同步到 std::cerr 的访问
    10.                  // 3) 为条件变量 cv
    11. int i = 0;
    12.  
    13. void waits()
    14. {
    15.     std::unique_lock<std::mutex> lk(cv_m);
    16.     std::cerr << "Waiting... \n";
    17.     cv.wait(lk, []{return i == 1;});
    18.     std::cerr << "...finished waiting. i == 1\n";
    19. }
    20.  
    21. void signals()
    22. {
    23.     std::this_thread::sleep_for(std::chrono::seconds(1));
    24.     {
    25.         std::lock_guard<std::mutex> lk(cv_m);
    26.         std::cerr << "Notifying...\n";
    27.     }
    28.     cv.notify_all();
    29.  
    30.     std::this_thread::sleep_for(std::chrono::seconds(1));
    31.  
    32.     {
    33.         std::lock_guard<std::mutex> lk(cv_m);
    34.         i = 1;
    35.         std::cerr << "Notifying again...\n";
    36.     }
    37.     cv.notify_all();
    38. }
    39.  
    40. int main()
    41. {
    42.     std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    43.     t1.join(); 
    44.     t2.join(); 
    45.     t3.join();
    46.     t4.join();
    47. }

    输出

    阻塞当前线程，直到条件变量被唤醒，或到指定时限时长后

    1. template< class Rep, class Period >
    2.  std::cv_status wait_for( std::unique_lock<std::mutex>& lock,
    3.                   const std::chrono::duration<Rep, Period>& rel_time); (1) (C++11起) 
    4.  
    5. template< class Rep, class Period, class Predicate > 
    6. bool wait_for( std::unique_lock<std::mutex>& lock,
    7.                const std::chrono::duration<Rep, Period>& rel_time,
    8.                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 类型对象，必须被当前线程锁定
    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() 调用后开始等待的线程。

    调用示例

    1. #include <iostream>
    2. #include <atomic>
    3. #include <condition_variable>
    4. #include <thread>
    5. #include <chrono>
    6. using namespace std::chrono;
    7.  
    8. std::condition_variable cv;
    9. std::mutex cv_m;
    10. int i;
    11.  
    12. void waits(int idx)
    13. {
    14.     std::unique_lock<std::mutex> lk(cv_m);
    15.     if (cv.wait_for(lk, milliseconds(idx * 100), [] {return i == 1;}))
    16.         std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n';
    17.     else
    18.     {
    19.         std::cerr << "Thread " << idx << " timed out. i == " << i << '\n';
    20.     }
    21. }
    22.  
    23. void signals()
    24. {
    25.     std::this_thread::sleep_for(milliseconds(120));
    26.     std::cerr << "Notifying...\n";
    27.     cv.notify_all();
    28.     std::this_thread::sleep_for(milliseconds(100));
    29.     {
    30.         std::lock_guard<std::mutex> lk(cv_m);
    31.         i = 1;
    32.     }
    33.     std::cerr << "Notifying again...\n";
    34.     cv.notify_all();
    35. }
    36.  
    37. int main()
    38. {
    39.     std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals);
    40.     t1.join();
    41.     t2.join();
    42.     t3.join();
    43.     t4.join();
    44. }

    输出


    阻塞当前线程，直到条件变量被唤醒，或直到抵达指定时间点

    1. template< class Clock, class Duration > 
    2. std::cv_status wait_until( std::unique_lock<std::mutex>& lock,
    3.       const std::chrono::time_point<Clock,
    4.  Duration>& timeout_time ); (1) (C++11 起) 
    5.  
    6. template< class Clock, class Duration, class Pred > 
    7. bool wait_until( std::unique_lock<std::mutex>& lock,
    8.  const std::chrono::time_point<Clock,
    9.  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 类型对象，必须被当前线程锁定
    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() 调用后开始等待的线程。

    调用示例

    1. #include <iostream>
    2. #include <atomic>
    3. #include <condition_variable>
    4. #include <thread>
    5. #include <chrono>
    6. using namespace std::chrono;
    7.  
    8. std::condition_variable cv;
    9. std::mutex cv_m;
    10. std::atomic<int> i{0};
    11.  
    12. void waits(int idx)
    13. {
    14.     std::unique_lock<std::mutex> lk(cv_m);
    15.     auto now = std::chrono::system_clock::now();
    16.     auto func = []()
    17.     {
    18.         return i == 1;
    19.     };
    20.  
    21.     if (cv.wait_until(lk, now + milliseconds(idx * 100), func))
    22.     {
    23.         std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n';
    24.     }
    25.     else
    26.     {
    27.         std::cerr << "Thread " << idx << " timed out. i == " << i << '\n';
    28.     }
    29. }
    30.  
    31. void signals()
    32. {
    33.     std::this_thread::sleep_for(milliseconds(120));
    34.     std::cerr << "Notifying...\n";
    35.     cv.notify_all();
    36.     std::this_thread::sleep_for(milliseconds(100));
    37.     i = 1;
    38.     std::cerr << "Notifying again...\n";
    39.     cv.notify_all();
    40. }
    41.  
    42. int main()
    43. {
    44.     std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals);
    45.     t1.join();
    46.     t2.join();
    47.     t3.join();
    48.     t4.join();
    49. }

    输出

     

  • 相关阅读:
    github新手用法详解
    lighttpd cgi不能重启
    浅谈网络损伤仪HoloWAN的使用场景
    【Android 】WebView和原生控件交互
    我做抖音小店无货源电商，2个月攒下16万！抖音电商真的好做吗？
    AWS认证是什么意思？怎么报考？
    day12 过一遍Nestjs框架（java转ts全栈/3R教室）
    SpringMVC中如何使用注解的方式实现文件上传呢？
    js 的 document element 的 querySelectorAll写在for外内速度测试2207302107
    享元模式【Java设计模式】
  • 原文地址：https://blog.csdn.net/qq_40788199/article/details/126436198