condition_variable (Clase)
Utilice la clase condition_variable para esperar un evento cuando tenga un mutex de tipo unique_lock<mutex>. Los objetos de este tipo pueden tener un rendimiento mejor que los objetos de tipo condition_variable_any<unique_lock<mutex>>.
Sintaxis
class condition_variable;
Miembros
Constructores
| Nombre | Descripción |
|---|---|
| condition_variable | Construye un objeto condition_variable. |
Funciones
| Nombre | Descripción |
|---|---|
| native_handle | Devuelve el tipo específico de la implementación que representa el identificador condition_variable. |
| notify_all | Desbloquea todos los subprocesos que están esperando el objeto condition_variable. |
| notify_one | Desbloquea uno de los subprocesos que están esperando el objeto condition_variable. |
| wait | Bloquea un subproceso. |
| wait_for | Bloquea un subproceso y establece un intervalo de tiempo después del cual el subproceso se desbloquea. |
| wait_until | Bloquea un subproceso y establece un punto máximo en el tiempo en el que el subproceso se desbloquea. |
condition_variable
Construye un objeto condition_variable.
condition_variable();
Comentarios
Si no queda suficiente memoria disponible, el constructor produce un objeto system_error que tiene un código de error de not_enough_memory. Si el objeto no puede construirse porque algún otro recurso no está disponible, el constructor produce un objeto system_error que tiene un código de error de resource_unavailable_try_again.
native_handle
Devuelve el tipo específico de la implementación que representa el identificador condition_variable.
native_handle_type native_handle();
Valor devuelto
native_handle_type se define como un puntero a estructuras de datos internas del Runtime de simultaneidad.
notify_all
Desbloquea todos los subprocesos que están esperando el objeto condition_variable.
void notify_all() noexcept;
notify_one
Desbloquea uno de los subprocesos que están esperando el objeto condition_variable.
void notify_one() noexcept;
wait
Bloquea un subproceso.
void wait(unique_lock<mutex>& Lck);
template <class Predicate>
void wait(unique_lock<mutex>& Lck, Predicate Pred);
Parámetros
Lck
Un objeto unique_lock<mutex>.
Pred
Cualquier expresión que devuelve true o false.
Comentarios
El primer método se bloquea hasta que el objeto condition_variable se señaliza mediante una llamada a notify_one o a notify_all. También se puede reactivar en falso.
En efecto, el segundo método ejecuta el código siguiente.
while(!Pred())
wait(Lck);
wait_for
Bloquea un subproceso y establece un intervalo de tiempo después del cual el subproceso se desbloquea.
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);
Parámetros
Lck
Un objeto unique_lock<mutex>.
Rel_time
Objeto chrono::duration que especifica la cantidad de tiempo que tiene que transcurrir hasta que el subproceso se reactive.
Pred
Cualquier expresión que devuelve true o false.
Valor devuelto
El primer método devuelve cv_status::timeout si la espera termina cuando Rel_time ha transcurrido. De lo contrario, el método devuelve cv_status::no_timeout.
El segundo método devuelve el valor de Pred.
Comentarios
El primer método se bloquea hasta que se señaliza el objeto condition_variable mediante una llamada a notify_one o notify_all, o hasta que el intervalo Rel_time ha transcurrido. También se puede reactivar en falso.
En efecto, el segundo método ejecuta el código siguiente.
while(!Pred())
if(wait_for(Lck, Rel_time) == cv_status::timeout)
return Pred();
return true;
wait_until
Bloquea un subproceso y establece un punto máximo en el tiempo en el que el subproceso se desbloquea.
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);
Parámetros
Lck
Un objeto unique_lock<mutex>.
Abs_time
Un objeto chrono::time_point.
Pred
Cualquier expresión que devuelve true o false.
Valor devuelto
Los métodos que devuelven un tipo cv_status devuelven cv_status::timeout si la espera termina cuando transcurre Abs_time. De lo contrario, los métodos devuelven cv_status::no_timeout.
Los métodos que devuelven un tipo bool devuelven el valor de Pred.
Comentarios
El primer método se bloquea hasta que el objeto condition_variable se señaliza mediante una llamada a notify_one o a notify_all, o hasta que transcurre Abs_time. También se puede reactivar en falso.
En efecto, el segundo método ejecuta el código siguiente
while(!Pred())
if(wait_until(Lck, Abs_time) == cv_status::timeout)
return Pred();
return true;
Los métodos tercero y cuarto utilizan un puntero a un objeto de tipo xtime para reemplazar el objeto chrono::time_point. El objeto xtime especifica el tiempo máximo que hay que esperar una señal.