CKTIS / C++
std::condition_variable: wachten op wijziging van gedeelde toestand
std::condition_variable blokkeert een thread terwijl een mutex atomair wordt vrijgegeven en wekt haar na melding, maar de voorwaarde moet altijd opnieuw worden getest.
Versie: C++23
Syntax
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 uit <condition_variable> coördineert threads met std::unique_lock<std::mutex>. wait ontgrendelt de mutex atomair en blokkeert, en neemt het slot vóór terugkeer opnieuw. notify_one wekt één wachtende thread; notify_all wekt ze allemaal.
Een melding bewaart geen toestand en kan verloren gaan als nog niemand wacht. Wijzig toestand zoals ready onder dezelfde mutex en wacht met wait(lock, pred), dat na spontane ontwakingen opnieuw test. Melden na ontgrendeling kan contention beperken.
De opgegeven unique_lock moet het slot bezitten en alle threads die op hetzelfde object wachten moeten dezelfde mutex gebruiken; schending veroorzaakt ongedefinieerd gedrag. Een getimede wacht kan later dan de deadline eindigen. Vernietig het object zodra geen thread er nog op geblokkeerd is; een vrijgegeven thread kan nog wachten om de mutex opnieuw te verkrijgen. Alle threads joinen, zoals in het voorbeeld, is een veilig levensduurpatroon en niet de letterlijke normeis.
Voorbeelden
#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';
}
Resultaat
42
std::condition_variable → 42