• Class / Function / Type

      std::
    • Header file

      <>
    • Other / All

    最終更新日時(UTC):
    が更新

    履歴 編集

    function template
    <condition_variable>

    std::condition_variable_any::wait_until

    template <class Lock, class Clock, class Duration>
    cv_status wait_until(Lock& lock,
                         const chrono::time_point<Clock, Duration>& abs_time); // (1)
    
    template <class Lock, class Clock, class Duration, class Predicate>
    bool wait_until(Lock& lock,
                    const chrono::time_point<Clock, Duration>& abs_time,
                    Predicate pred);                                           // (2)
    
    template<class Lock, class Clock, class Duration, class Predicate>
    bool wait_until(Lock& lock,
                    stop_token stoken,
                    const chrono::time_point<Clock, Duration>& abs_time,
                    Predicate pred);                                           // (3) C++20 から
    

    概要

    絶対時間でタイムアウトを指定して、起床されるまで待機する。

    この関数は、処理をするための準備ができたことをnotify_one()/notify_all()によって通知されるまでスレッドを待機するために使用する。

    述語を指定しない場合、notify_one()/notify_all()が呼び出された時点でこの関数のブロッキングが解除される。

    述語を指定する場合、述語呼び出しがtrueになるまで待機を続行する。

    テンプレートパラメータ制約

    効果

    • (1) :

      • アトミックにlock.unlock()する
      • notify_one()/notify_all()による通知、abs_timeによって指定された時間に到達したことによる期限切れ、もしくはなんらかの理由によって失敗するまでブロッキングする
      • この関数を抜ける際にlock.lock()する
      • この関数が例外送出によって終了する場合、関数を抜ける前にlock.lock()する
    • (2) : 以下と等価の処理を行う

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

    • (3) : このメンバ関数呼び出しの間だけstokenに対する停止要求によって*thisへ通知が行われるよう登録し、以下と等価の処理を行う

    while (!stoken.stop_requested()) {
      if (pred())
        return true;
      if (cv.wait_until(lock, abs_time) == cv_status::timeout)
        return pred();
    }
    return pred();
    

    戻り値

    • (1) : abs_timeで指定された絶対時間内に起床されない場合、タイムアウトとなりcv_status::timeoutが返る。そうでない場合はcv_status::no_timeoutが返る。
    • (2) : pred()の結果が返る。
    • (3) : 停止要求の有無によらず、pred()の結果が返る。

    事後条件

    lockが参照しているミューテックスオブジェクトが、この関数を呼び出したスレッドでロック取得されていること

    例外

    • (1) :
      • C++11まで : この関数は、lock.lock()およびlock.unlock()によって送出されうる、あらゆる例外が送出される可能性がある。
      • C++14 : 時計クラス、time_pointクラス、durationクラスの構築が例外を送出する場合、この関数はそれらの例外を送出する。
    • (2) :
      • C++11まで : この関数は、lock.lock()およびlock.unlock()によって送出されうる、あらゆる例外が送出される可能性がある。
      • C++14 : 時計クラス、time_pointクラス、durationクラスの構築が例外を送出する場合、この関数はそれらの例外を送出する。またはpred()により送出された例外
    • (3) :
      • 時計クラス、time_pointクラス、durationクラスの構築が例外を送出する場合、この関数はそれらの例外を送出する。またはpred()により送出された例外

    備考

    • C++14 : 事後条件を満たさない場合、std::terminate()関数を呼び出して、プログラムを異常終了させる。これは、ミューテックスの再ロック取得が例外を送出した場合に発生する。

    #include <iostream>
    #include <condition_variable>
    #include <mutex>
    #include <thread>
    #include <chrono>
    
    struct ProcessData {
      std::recursive_mutex mtx_;
      std::condition_variable_any cond_;
    
      bool data_ready_ = false;
    
    public:
      // 処理に必要なデータの準備をする
      void prepare_data_for_processing()
      {
        // ...準備処理...
    
        {
          std::lock_guard<std::recursive_mutex> lk(mtx_);
          data_ready_ = true;
        }
    
        // 準備完了したので待機スレッドを全て起床させる
        cond_.notify_all();
      }
    
      void wait_until_data_to_process1()
      {
        std::unique_lock<std::recursive_mutex> lk(mtx_);
    
        // データの準備ができるまで待機してから処理する
        while (!data_ready_) {
          // 述語を指定しないバージョン
          // 3秒でタイムアウト
          using namespace std::chrono;
          steady_clock::time_point tp = steady_clock::now() + seconds(3);
          std::cv_status result = cond_.wait_until(lk, tp);
          if (result == std::cv_status::timeout) {
            std::cout << "wait_until_data_to_process1 : timeout" << std::endl;
            return;
          }
        }
        process_data();
      }
    
      void wait_until_data_to_process2()
      {
        std::unique_lock<std::recursive_mutex> lk(mtx_);
    
        // データの準備ができるまで待機してから処理する
    
        // 述語を指定するバージョン
        // 3秒でタイムアウト
        using namespace std::chrono;
        steady_clock::time_point tp = steady_clock::now() + seconds(3);
        if (!cond_.wait_until(lk, tp, [this] { return data_ready_; })) {
          // data_ready == false
          std::cout << "data is not ready" << std::endl;
          return;
        }
        process_data();
      }
    
    private:
      void process_data()
      {
        // ...データを処理する...
        std::cout << "process data" << std::endl;
      }
    };
    
    int main()
    {
      ProcessData p;
    
      std::thread t1([&] { p.prepare_data_for_processing(); });
      std::thread t2([&] { p.wait_until_data_to_process1(); });
      std::thread t3([&] { p.wait_until_data_to_process2(); });
    
      t1.join();
      t2.join();
      t3.join();
    }
    

    出力例

    process data
    process data
    

    バージョン

    言語

    • C++11

    処理系

    参照