Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

std::condition_variable: čekání na změnu sdíleného stavu

std::condition_variable zablokuje vlákno s atomickým odemknutím mutexu a probudí je po oznámení, podmínku je však vždy nutné znovu ověřit.

Verze: C++23

Syntaxe

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 z <condition_variable> koordinuje vlákna pomocí std::unique_lock<std::mutex>. wait atomicky odemkne mutex a zablokuje se, před návratem zámek znovu získá. notify_one probudí jedno čekající vlákno, notify_all všechna.

Oznámení neuchovává stav a může se ztratit, pokud ještě nikdo nečeká. Stav jako ready měň pod stejným mutexem a čekej přes wait(lock, pred), které test opakuje po falešných probuzeních. Oznámit lze po odemknutí a omezit tak soupeření.

Předaný unique_lock musí zámek vlastnit a všechna vlákna čekající na stejném objektu musí používat stejný mutex; porušení vede k nedefinovanému chování. Časované čekání může skončit po termínu. Objekt znič, až když na něm už není zablokováno žádné vlákno; odblokované vlákno může ještě čekat na opětovné získání mutexu. Připojení všech vláken jako v příkladu je bezpečný vzor životnosti, nikoli doslovný požadavek normy.

Příklady

#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';
}

Výsledek

42

std::condition_variable → 42

Zdroje