最終更新日時:
が更新

履歴 編集

function
<condition_variable>

std::condition_variable_any::wait_until(C++11)

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)

概要

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

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

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

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

効果

  • (1) :

    • アトミックにlock.[unlock()](/reference/mutex/unique_lock/unlock.md)する
    • 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;

戻り値

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

事後条件

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

例外

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

備考

  • 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

処理系

参照