std::condition_variable:: wait

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

Inmediatamente después de que wait retorne, lock. owns_lock ( ) es true , y lock. mutex ( ) está bloqueado por el hilo que realiza la llamada. Si estas postcondiciones no pueden satisfacerse ^[1] , se llama a std::terminate .

Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:

• lock. owns_lock ( ) es false .
• lock. mutex ( ) no está bloqueado por el hilo que realiza la llamada.
• Si otros hilos también están esperando en * this , lock. mutex ( ) es diferente del mutex desbloqueado por las funciones de espera ( wait , wait_for y wait_until ) llamadas en * this por esos hilos.

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

Parámetros

Excepciones

Notas

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 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 << "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

Informes de defectos

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

Véase también

Enlaces externos