std::condition_variable::wait

wait hace que el hilo actual se bloquee hasta que se notifique a la variable de condición o se produzca un despertar espurio, opcionalmente en bucle hasta que se satisfaga algún predicado.

while (!pred()) {
    wait(lock);
}

Si estas funciones no cumplen con las poscondiciones (lock.owns_lock()==true y lock.mutex() se bloquea por el hilo llamante), se llama a std::terminate. Por ejemplo, esto podría suceder si al volver a bloquear el mutex se lanza una excepción.

[editar] Parámetros

[editar] Valor de retorno

(Ninguno)

[editar] Excepciones

[editar] Notas

Llamar a esta función si lock.mutex() no está bloqueado por el hilo actual resulta en comportamiento no definido.

Llamar a esta función si lock.mutex() no es el mismo mutex que el usado por todos los otros hilos que se encuentran a la espera en la misma variable de condición resulta en comportamiento no definido.

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) tienen lugar en un solo orden total que se puede ver como el orden de modificación de una variable atómica: el orden es específico para esta variable de condición individual. Esto hace imposible que notify_one() por ejemplo, se retrase y desbloquee un hilo que comenzó a esperar justo después de que se hizo la llamada a notify_one().

[editar] Ejemplo

#include <iostream>
#include <condition_variable>
#include <thread>
#include <chrono>
 
std::condition_variable cv;
std::mutex cv_m; // Se usa este mutex para tres propósitos:
                 // 1) para sincronizar accesos a i
                 // 2) para sincronizar accesos a std::cerr
                 // 3) para la variable de condición cv
int i = 0;
 
void espera()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "En espera... \n";
    cv.wait(lk, []{return i == 1;});
    std::cerr << "...terminada la espera. i == 1\n";
}
 
void indica()
{
    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(espera), t2(espera), t3(espera), t4(indica);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

En espera...
En espera...
En espera...
Notificando...
Notificando de nuevo...
...terminada la espera. i == 1
...terminada la espera. i == 1
...terminada la espera. i == 1

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también