CKTIS / C++
std::condition_variable: attendere il cambiamento di stato condiviso
std::condition_variable blocca un thread rilasciando atomicamente un mutex e lo risveglia dopo una notifica, ma la condizione va sempre ricontrollata.
Versione: C++23
Sintassi
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 di <condition_variable> coordina thread tramite std::unique_lock<std::mutex>. wait sblocca atomicamente il mutex e si blocca, quindi riacquisisce il lock prima di restituire. notify_one risveglia un thread in attesa, mentre notify_all li risveglia tutti.
Una notifica non conserva stato e può andare persa se nessuno sta ancora aspettando. Modifica uno stato come ready sotto lo stesso mutex e attendi con wait(lock, pred), che ripete il controllo dopo risvegli spuri. La notifica può avvenire dopo lo sblocco per ridurre la contesa.
Il unique_lock fornito deve possedere il lock e tutti i thread in attesa sullo stesso oggetto devono usare lo stesso mutex; la violazione causa comportamento indefinito. Un’attesa temporizzata può finire dopo la scadenza. Distruggi l’oggetto quando nessun thread è più bloccato su di esso; un thread sbloccato può attendere ancora di riacquisire il mutex. Fare join di tutti i thread, come nell’esempio, è un modello sicuro di gestione della durata, non il requisito letterale della norma.
Esempi
#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';
}
Risultato
42
std::condition_variable → 42