std::condition_variable_any:: wait_for

wait_for hace que el hilo actual se bloquee hasta que la variable de condición sea notificada, haya transcurrido la duración dada, o ocurra un despertar espurio. pred puede proporcionarse opcionalmente para detectar despertar espurio.

Inmediatamente después de que wait_for retorne, lock está bloqueado por el hilo que realiza la llamada. Si esta postcondición no puede satisfacerse ^[1] , llama a std::terminate .

1. ↑ Esto puede ocurrir si el re-bloqueo del mutex lanza una excepción.

Parámetros

Valor de retorno

Excepciones

Notas

Aunque se notifique bajo bloqueo, la sobrecarga (1) no ofrece garantías sobre el estado del predicado asociado al retornar por tiempo de espera agotado.

Los efectos de notify_one() / notify_all() y cada una de las tres partes atómicas de wait() / wait_for() / wait_until() (desbloquear+esperar, despertar y bloquear) ocurren en un único orden total que puede verse como el orden de modificación de una variable atómica: el orden es específico de esta variable de condición individual. Esto hace imposible que notify_one() pueda, por ejemplo, retrasarse y desbloquear un hilo que comenzó a esperar justo después de que se realizara la llamada a notify_one() .

Ejemplo

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <thread>
std::condition_variable_any cv;
std::mutex cv_m; // Este mutex se utiliza para tres propósitos:
                 // 1) sincronizar accesos a i
                 // 2) sincronizar accesos a std::cerr
                 // 3) para la variable de condición cv
int i = 0;
void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "Esperando... \n";
    cv.wait(lk, []{ return i == 1; });
    std::cerr << "...finalizada la espera. i == 1\n";
}
void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notificando...\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 << "Notificando de nuevo...\n";
    }
    cv.notify_all();
}
int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

Esperando...
Esperando...
Esperando...
Notificando...
Notificando de nuevo...
...finalizada la espera. i == 1
...finalizada la espera. i == 1
...finalizada la espera. i == 1

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también