std::condition_variable_any:: wait

wait provoque le blocage du thread actuel jusqu'à ce que la variable de condition soit notifiée ou qu'un réveil intempestif se produise. pred peut être optionnellement fourni pour détecter les réveils intempestifs.

Immédiatement après que wait retourne, lock est verrouillé par le thread appelant. Si cette postcondition ne peut être satisfaite ^[1] , appelle std::terminate .

1. ↑ Cela peut se produire si le nouveau verrouillage du mutex lève une exception.

Paramètres

Valeur de retour

Exceptions

Notes

La valeur de retour de la surcharge (3) indique si pred a évalué à true , indépendamment du fait qu'une interruption ait été demandée ou non.

Les effets de notify_one() / notify_all() et chacune des trois parties atomiques de wait() / wait_for() / wait_until() (déverrouillage+attente, réveil et verrouillage) se produisent dans un ordre total unique qui peut être considéré comme l'ordre de modification d'une variable atomique : cet ordre est spécifique à cette variable conditionnelle individuelle. Cela rend impossible, par exemple, que notify_one() soit retardé et débloque un thread qui a commencé à attendre juste après l'appel à notify_one() ait été effectué.

Exemple

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <thread>
std::condition_variable_any cv;
std::mutex cv_m; // Ce mutex est utilisé à trois fins :
                 // 1) synchroniser les accès à i
                 // 2) synchroniser les accès à std::cerr
                 // 3) pour la variable condition cv
int i = 0;
void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "En attente... \n";
    cv.wait(lk, []{ return i == 1; });
    std::cerr << "...fin de l'attente. i == 1\n";
}
void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notification...\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 << "Nouvelle notification...\n";
    }
    cv.notify_all();
}
int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

En attente...
En attente...
En attente...
Notification...
Nouvelle notification...
...fin de l'attente. i == 1
...fin de l'attente. i == 1
...fin de l'attente. i == 1

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

Liens externes