最終更新日時(UTC): 2024年06月11日 13時45分38秒
Akira Takahashi が更新

function template

std::condition_variable_any::wait_for

template <class Lock, class Rep, class Period>
cv_status wait_for(Lock& lock,
                   const chrono::duration<Rep, Period>& rel_time); // (1)

template <class Lock, class Rep, class Period, class Predicate>
bool wait_for(Lock& lock,
              const chrono::duration<Rep, Period>& rel_time,
              Predicate pred);                                     // (2)

template<class Lock, class Rep, class Period, class Predicate>
bool wait_for(Lock& lock,
              stop_token stoken,
              const chrono::duration<Rep, Period>& rel_time,
              Predicate pred);                                     // (3) C++20 から

概要

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

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

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

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

戻り値

(1) :

return wait_until(lock, chrono::steady_clock::now() + rel_time);

rel_timeで指定された相対時間内に起床されない場合、タイムアウトとなりcv_status::timeoutが返る。そうでない場合はcv_status::no_timeoutが返る。

(2) :

return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));

pred()が最初からtrueの場合、またはすでに期限が過ぎている場合、この関数はブロッキングしない

(3) :

return wait_until(lock, std::move(stoken), chrono::steady_clock::now() + rel_time,
                  std::move(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>

namespace chrono = std::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_for_data_to_process1()
  {
    std::unique_lock<std::recursive_mutex> lk(mtx_);

    // データの準備ができるまで待機してから処理する
    while (!data_ready_) {
      // 述語を指定しないバージョン
      // 3秒でタイムアウト
      std::cv_status result = cond_.wait_for(lk, chrono::seconds(3));
      if (result == std::cv_status::timeout) {
        std::cout << "wait_for_data_to_process1 : timeout" << std::endl;
        return;
      }
    }
    process_data();
  }

  void wait_for_data_to_process2()
  {
    std::unique_lock<std::recursive_mutex> lk(mtx_);

    // データの準備ができるまで待機してから処理する

    // 述語を指定するバージョン
    // 3秒でタイムアウト
    if (!cond_.wait_for(lk, chrono::seconds(3), [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_for_data_to_process1(); });
  std::thread t3([&] { p.wait_for_data_to_process2(); });

  t1.join();
  t2.join();
  t3.join();
}

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

namespace chrono = std::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_for_data_to_process1()
  {
    std::unique_lock<std::recursive_mutex> lk(mtx_);

// データの準備ができるまで待機してから処理する
    while (!data_ready_) {
      // 述語を指定しないバージョン
      // 3秒でタイムアウト
      std::cv_status result = cond_.wait_for(lk, chrono::seconds(3));
      if (result == std::cv_status::timeout) {
        std::cout << "wait_for_data_to_process1 : timeout" << std::endl;
        return;
      }
    }
    process_data();
  }

void wait_for_data_to_process2()
  {
    std::unique_lock<std::recursive_mutex> lk(mtx_);

// データの準備ができるまで待機してから処理する

// 述語を指定するバージョン
    // 3秒でタイムアウト
    if (!cond_.wait_for(lk, chrono::seconds(3), [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_for_data_to_process1(); });
  std::thread t3([&] { p.wait_for_data_to_process2(); });

t1.join();
  t2.join();
  t3.join();
}

xxxxxxxxxx
 
#include <iostream>
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
​
namespace chrono = std::chrono;
​
struct ProcessData {
  std::recursive_mutex mtx_;
  std::condition_variable_any cond_;
​
  bool data_ready_ = false;
​
public:
  // 処理に必要なデータの準備をする
  void prepare_data_for_processing()
  {

出力例

process data
process data

std::condition_variable_any::wait_for

概要

戻り値

事後条件

例外

備考

例

出力例

バージョン

言語

処理系

参照