##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::condition_variable_any::wait_for

From cppreference.com
< cpp‎ | thread‎ | condition variable any

[edit template]

template< class Lock, class Rep, class Period > std::cv_status wait_for( Lock& lock, const std::chrono::duration<Rep, Period>& rel_time); | (1) | (since C++11)
template< class Lock, class Rep, class Period, class Predicate > bool wait_for( Lock& lock, const std::chrono::duration<Rep, Period>& rel_time, Predicate pred); | (2) | (since C++11)

1) Atomically releases `lock`, blocks the current executing thread, and adds it to the list of threads waiting on *this. The thread will be unblocked when notify_all() or notify_one() is executed, or when the relative timeout `rel_time` expires. It may also be unblocked spuriously. When unblocked, regardless of the reason, `lock` is reacquired and `wait_for()` exits. If this function exits via exception, `lock` is also reacquired. (until C++14)
2) Equivalent to return wait_until(lock, std::chrono::steady_clock::now() + rel_time, std::move(pred));. This overload may be used to ignore spurious awakenings.

A steady clock is used to measure the duration. This function may block for longer than `timeout_duration` due to scheduling or resource contention delays.

If these functions fail to meet the postcondition (lock is locked by the calling thread), std::terminate is called. For example, this could happen if relocking the mutex throws an exception, | (since C++14)

### [edit] Parameters

lock | - | an object of type `Lock` that meets the `BasicLockable` requirements, which must be locked by the current thread
rel_time | - | an object of type std::chrono::duration representing the maximum time to spend waiting
pred | - | predicate which returns ​false if the waiting should be continued. The signature of the predicate function should be equivalent to the following: bool pred();​

### [edit] Return value

1) std::cv_status::timeout if the relative timeout specified by `rel_time` expired, std::cv_status::no_timeout otherwise.
2) false if the predicate `pred` still evaluates to false after the `rel_time` timeout expired, otherwise true.

### [edit] Exceptions

1)

May throw std::system_error, may also propagate exceptions thrown by lock.lock() or lock.unlock(). | (until C++14)
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw) | (since C++14)

2) Same as (1) but may also propagate exceptions thrown by `pred`

### [edit] Notes

Even if notified under lock, overload (1) makes no guarantees about the state of the associated predicate when returning due to timeout.

The effects of `notify_one()`/`notify_all()` and each of the three atomic parts of `wait()`/`wait_for()`/`wait_until()` (unlock+wait, wakeup, and lock) take place in a single total order that can be viewed as modification order of an atomic variable: the order is specific to this individual condition_variable. This makes it impossible for `notify_one()` to, for example, be delayed and unblock a thread that started waiting just after the call to `notify_one()` was made.

### [edit] Example

Run this code

    #include <iostream>
    #include <atomic>
    #include <condition_variable>
    #include <thread>
    #include <chrono>
    using namespace std::chrono_literals;

    std::condition_variable_any cv;
    std::mutex cv_m;
    int i;

    void waits(int idx)
    {
        std::unique_lock<std::mutex> lk(cv_m);
        if(cv.wait_for(lk, idx*100ms, []{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(120ms);
        std::cerr << "Notifying...\n";
        cv.notify_all();
        std::this_thread::sleep_for(100ms);
        {
            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();
    }

Output:

    Thread 1 timed out. i == 0
    Notifying...
    Thread 2 timed out. i == 0
    Notifying again...
    Thread 3 finished waiting. i == 1

### [edit] See also

wait | blocks the current thread until the condition variable is woken up (public member function) [edit]
wait_until | blocks the current thread until the condition variable is woken up or until specified time point has been reached (public member function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/thread/condition_variable_any/wait_for&oldid=51349"
Hidden category:

- Pages with unreviewed LWG DR marker