Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::condition_variable : attendre un changement d’état partagé

std::condition_variable bloque un thread en libérant atomiquement un mutex et le réveille après notification, mais la condition doit toujours être revérifiée.

Version : 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 de <condition_variable> coordonne des threads avec std::unique_lock<std::mutex>. wait libère atomiquement le mutex et bloque, puis reprend le verrou avant de rendre la main. notify_one réveille un thread en attente et notify_all les réveille tous.

Une notification ne mémorise aucun état et peut être perdue si personne n’attend encore. Modifie un état comme ready sous le même mutex et attends avec wait(lock, pred), qui recommence le test après les réveils intempestifs. La notification peut suivre le déverrouillage pour réduire la contention.

Le unique_lock fourni doit posséder le verrou et tous les threads attendant sur le même objet doivent employer le même mutex ; violer ces exigences entraîne un comportement indéfini. Une attente temporisée peut finir après son échéance. Ne détruis l’objet que lorsqu’aucun thread n’y est encore bloqué ; un thread débloqué peut toujours attendre de reprendre le mutex. Joindre tous les threads, comme dans l’exemple, est un modèle sûr de gestion de durée de vie, pas l’exigence littérale de la norme.

Exemples

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

Résultat

42

std::condition_variable → 42

Sources