std::condition_variable::wait_for

template< class Rep, class Period >
std::cv_status wait_for( std::unique_lock<std::mutex>& lock,
                         const std::chrono::duration<Rep, Period>& rel_time );

template< class Rep, class Period, class Predicate >
bool wait_for( std::unique_lock<std::mutex>& lock,
               const std::chrono::duration<Rep, Period>& rel_time,
               Predicate pred );

wait_for блокирует текущий поток до тех пор, пока не будет выполнено одно из следующих условий: условная переменная не будет уведомлена, не истечёт заданный интервал времени или не произойдёт ложное пробуждение. pred можно указать, чтобы обнаруживать ложные пробуждения.

Сразу после возврата wait_for значение lock.owns_lock() равно true, а lock.mutex() заблокирован вызывающим потоком. Если эти постусловия не могут быть выполнены^[1], вызовы std::terminate.

Если выполняется любое из следующих условий, поведение не определено:

• lock.owns_lock() равен false.
• lock.mutex() не заблокирован вызывающим потоком.
• Если на *this также ожидают другие потоки, lock.mutex() отличается от мьютекса, разблокированного функциями ожидания (wait, wait_for и wait_until), вызванными этими потоками для *this.

Параметры

Возвращаемое значение

Исключения

Примечания

Даже если уведомление было отправлено при заблокированном мьютексе, перегрузка (1) не гарантирует состояние связанного предиката при возврате по тайм-ауту.

Эффекты notify_one()/notify_all() и каждая из трёх атомарных частей wait()/wait_for()/wait_until() (разблокировка и ожидание, пробуждение и блокировка) происходят в едином общем порядке, который можно рассматривать как порядок модификации атомарной переменной: этот порядок определяется отдельно для каждой условной переменной. Благодаря этому notify_one() не может, например, задержаться и разблокировать поток, который начал ожидание сразу после вызова notify_one().

Пример

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

std::condition_variable cv;
std::mutex cv_m; // This mutex is used for three purposes:
                 // 1) to synchronize accesses to i
                 // 2) to synchronize accesses to std::cerr
                 // 3) for the condition variable cv
int i = 0;

void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "Waiting... \n";
    cv.wait(lk, []{ return i == 1; });
    std::cerr << "...finished waiting. i == 1\n";
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notifying...\n";
    }
    cv.notify_all();

    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lk(cv_m);
        i = 1;
        std::cerr << "Notifying again...\n";
    }
    cv.notify_all();
}

int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

Waiting...
Waiting...
Waiting...
Notifying...
Notifying again...
...finished waiting. i == 1
...finished waiting. i == 1
...finished waiting. i == 1

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

См. также