Namespaces
Variants

Standard library header <condition_variable> (C++11)

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque de support des threads .

Table des matières

Classes

(C++11)
fournit une variable de condition associée à un std::unique_lock
(classe)
(C++11)
fournit une variable de condition associée à tout type de verrou
(classe)
(C++11)
énumère les résultats possibles des attentes temporisées sur les variables de condition
(enum)

Fonctions

(C++11)
planifie un appel à notify_all à invoquer lorsque ce thread est complètement terminé
(fonction)

Synopsis 

namespace std {
  class condition_variable;
  class condition_variable_any;
  void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
  enum class cv_status { no_timeout, timeout };
}
**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` 
` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Classe std::condition_variable 

namespace std {
  class condition_variable {
  public:
    condition_variable();
    ~condition_variable();
    condition_variable(const condition_variable&) = delete;
    condition_variable& operator=(const condition_variable&) = delete;
    void notify_one() noexcept;
    void notify_all() noexcept;
    void wait(unique_lock<mutex>& lock);
    template<class Pred>
      void wait(unique_lock<mutex>& lock, Pred pred);
    template<class Clock, class Duration>
      cv_status wait_until(unique_lock<mutex>& lock,
                           const chrono::time_point<Clock, Duration>& abs_time);
    template<class Clock, class Duration, class Pred>
      bool wait_until(unique_lock<mutex>& lock,
                      const chrono::time_point<Clock, Duration>& abs_time, Pred pred);
    template<class Rep, class Period>
      cv_status wait_for(unique_lock<mutex>& lock,
                         const chrono::duration<Rep, Period>& rel_time);
    template<class Rep, class Period, class Pred>
      bool wait_for(unique_lock<mutex>& lock,
                    const chrono::duration<Rep, Period>& rel_time, Pred pred);
    using native_handle_type = /* implementation-defined */;
    native_handle_type native_handle();
  };
}

Classe std::condition_variable_any 

namespace std {
  class condition_variable_any {
  public:
    condition_variable_any();
    ~condition_variable_any();
    condition_variable_any(const condition_variable_any&) = delete;
    condition_variable_any& operator=(const condition_variable_any&) = delete;
    void notify_one() noexcept;
    void notify_all() noexcept;
    // attentes non interruptibles
    template<class Lock>
      void wait(Lock& lock);
    template<class Lock, class Pred>
      void wait(Lock& lock, Pred pred);
    template<class Lock, class Clock, class Duration>
      cv_status wait_until(Lock& lock,
                           const chrono::time_point<Clock, Duration>& abs_time);
    template<class Lock, class Clock, class Duration, class Pred>
      bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time,
                      Pred pred);
    template<class Lock, class Rep, class Period>
      cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
    template<class Lock, class Rep, class Period, class Pred>
      bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Pred pred);
    // attentes interruptibles
    template<class Lock, class Pred>
      bool wait(Lock& lock, stop_token stoken, Pred pred);
    template<class Lock, class Clock, class Duration, class Pred>
      bool wait_until(Lock& lock, stop_token stoken,
                      const chrono::time_point<Clock, Duration>& abs_time, Pred pred);
    template<class Lock, class Rep, class Period, class Pred>
      bool wait_for(Lock& lock, stop_token stoken,
                    const chrono::duration<Rep, Period>& rel_time, Pred pred);
  };
}