CKTIS / C++
std::condition_variable: esperar cambios del estado compartido
std::condition_variable bloquea un hilo liberando atómicamente un mutex y lo despierta tras una notificación, pero la condición siempre debe comprobarse otra vez.
Versión: C++23
Sintaxis
class condition_variable {
public:
void notify_one() noexcept;
void notify_all() noexcept;
void wait(std::unique_lock<std::mutex>& lock);
template<class Predicate>
void wait(std::unique_lock<std::mutex>& lock, Predicate pred);
};std::condition_variable, de <condition_variable>, coordina hilos mediante std::unique_lock<std::mutex>. wait libera atómicamente el mutex y bloquea, y recupera el bloqueo antes de retornar. notify_one despierta un hilo en espera y notify_all los despierta a todos.
Una notificación no almacena estado y puede perderse si todavía nadie espera. Modifica estados como ready bajo el mismo mutex y espera con wait(lock, pred), que repite la comprobación después de despertares espurios. Se puede notificar después de desbloquear para reducir contención.
El unique_lock proporcionado debe poseer el bloqueo y todos los hilos que esperan en el mismo objeto deben usar el mismo mutex; incumplirlo causa comportamiento indefinido. Una espera temporizada puede terminar después del plazo. Destruye el objeto cuando ningún hilo siga bloqueado en él; un hilo desbloqueado aún puede estar esperando recuperar el mutex. Unir todos los hilos, como hace el ejemplo, es un patrón seguro de vida útil, no el requisito literal de la norma.
Ejemplos
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
int main() {
std::mutex mutex;
std::condition_variable ready_changed;
bool ready = false;
int value = 0;
std::jthread worker([&] {
std::unique_lock lock(mutex);
ready_changed.wait(lock, [&] { return ready; });
value *= 2;
});
{
std::lock_guard lock(mutex);
value = 21;
ready = true;
}
ready_changed.notify_one();
worker.join();
std::cout << value << '\n';
}
Resultado
42
std::condition_variable → 42