condition_variable, classe

Utilisez la classe condition_variable pour attendre un événement quand vous avez un mutex de type unique_lock<mutex>. Les objets de ce type peuvent avoir de meilleures performances que les objets de type condition_variable_any<unique_lock<mutex>>.

Syntaxe

class condition_variable;

Membres

Constructeurs

Functions

condition_variable

Construit un objet condition_variable.

condition_variable();

Notes

Si la mémoire disponible n’est pas suffisante, le constructeur lève un objet system_error avec le code d’erreur not_enough_memory. Si l’objet ne peut pas être construit, car une autre ressource n’est pas disponible, le constructeur lève un objet system_error avec le code d’erreur resource_unavailable_try_again.

native_handle

Retourne le type spécifique de l’implémentation qui représente le descripteur condition_variable.

native_handle_type native_handle();

Valeur de retour

native_handle_type est défini comme un pointeur vers les structures de données internes du runtime d’accès concurrentiel.

notify_all

Débloque tous les threads qui attendent l’objet condition_variable.

void notify_all() noexcept;

notify_one

Débloque un des threads qui attendent l’objet condition_variable.

void notify_one() noexcept;

wait

Bloque un thread.

void wait(unique_lock<mutex>& Lck);

template <class Predicate>
void wait(unique_lock<mutex>& Lck, Predicate Pred);

Paramètres

Lck
Objet mutex> unique_lock<.

Pred
Toute expression valide qui retourne true ou false.

Notes

La première méthode se bloque jusqu’à ce que l’objet condition_variable soit signalé par un appel à notify_one ou notify_all. Elle peut également s’éveiller sans motif.

La deuxième méthode exécute le code suivant.

while(!Pred())
    wait(Lck);

wait_for

Bloque un thread et définit un intervalle de temps après lequel le thread est débloqué.

template <class Rep, class Period>
cv_status wait_for(
    unique_lock<mutex>& Lck,
    const chrono::duration<Rep, Period>& Rel_time);

template <class Rep, class Period, class Predicate>
bool wait_for(
    unique_lock<mutex>& Lck,
    const chrono::duration<Rep, Period>& Rel_time,
    Predicate Pred);

Paramètres

Lck
Objet mutex> unique_lock<.

Rel_time
Objet chrono::duration qui spécifie le délai avant l’éveil du thread.

Pred
Toute expression valide qui retourne true ou false.

Valeur de retour

La première méthode retourne cv_status::timeout si l’attente se termine lorsque Rel_time s’est écoulé. Dans le cas contraire, la méthode retourne cv_status::no_timeout.

La deuxième méthode retourne la valeur de Pred.

Notes

La première méthode se bloque jusqu’à ce que l’objet condition_variable soit signalé par un appel à notify_one ou notify_all ou jusqu’à ce que l’intervalle de temps Rel_time s’est écoulé. Elle peut également s’éveiller sans motif.

La deuxième méthode exécute le code suivant.

while(!Pred())
    if(wait_for(Lck, Rel_time) == cv_status::timeout)
    return Pred();

return true;

wait_until

Bloque un thread et définit un point dans le temps maximal auquel le thread est débloqué.

template <class Clock, class Duration>
cv_status wait_until(
    unique_lock<mutex>& Lck,
    const chrono::time_point<Clock, Duration>& Abs_time);

template <class Clock, class Duration, class Predicate>
bool wait_until(
    unique_lock<mutex>& Lck,
    const chrono::time_point<Clock, Duration>& Abs_time,
    Predicate Pred);

cv_status wait_until(
    unique_lock<mutex>& Lck,
    const xtime* Abs_time);

template <class Predicate>
bool wait_until(
    unique_lock<mutex>& Lck,
    const xtime* Abs_time,
    Predicate Pred);

Paramètres

Lck
Objet mutex> unique_lock<.

Abs_time
Objet chrono::time_point.

Pred
Toute expression valide qui retourne true ou false.

Valeur de retour

Méthodes qui retournent un cv_status type de retour cv_status::timeout si l’attente se termine lorsque Abs_time s’écoule. Sinon, les méthodes retournent cv_status::no_timeout.

Méthodes qui retournent une bool valeur de retour de Pred.

Notes

La première méthode se bloque jusqu’à ce que l’objet condition_variable soit signalé par un appel à notify_one ou notify_all, ou jusqu’à Abs_time. Elle peut également s’éveiller sans motif.

La deuxième méthode exécute le code suivant

while(!Pred())
    if(wait_until(Lck, Abs_time) == cv_status::timeout)
    return Pred();

return true;

Les troisième et quatrième méthodes utilisent un pointeur vers un objet de type xtime pour remplacer l’objet chrono::time_point. L’objet xtime spécifie le délai d’attente maximal d’un signal.

Voir aussi

Informations de référence sur les fichiers d’en-tête
<condition_variable>