std::atomic<T>:: wait

Effectue des opérations d'attente atomiques. Se comporte comme s'il effectuait de manière répétée les étapes suivantes :

• Comparez la représentation de valeur de this - > load ( order ) avec celle de old .
  • Si elles sont égales, se bloque jusqu'à ce que * this soit notifié par notify_one() ou notify_all() , ou que le thread soit débloqué de manière sporadique.
  • Sinon, retourne immédiatement.

Ces fonctions garantissent de ne retourner que si la valeur a changé, même si l'implémentation sous-jacente se débloque de manière intempestive.

Si order n'est pas std:: memory_order_relaxed , std:: memory_order_consume , std:: memory_order_acquire ou std:: memory_order_seq_cst , le comportement est indéfini.

Paramètres

Notes

Cette forme de détection de changement est souvent plus efficace qu'un simple sondage ou que des verrous d'attente active purs.

En raison du problème ABA , les changements transitoires de old vers une autre valeur et de retour à old pourraient ne pas être détectés, et ne pas débloquer.

La comparaison est effectuée bit à bit (similaire à std::memcmp ) ; aucun opérateur de comparaison n'est utilisé. Les bits de remplissage qui ne participent jamais à la représentation de la valeur d'un objet sont ignorés.

Exemple

#include <atomic>
#include <chrono>
#include <future>
#include <iostream>
#include <thread>
using namespace std::literals;
int main()
{
    std::atomic<bool> all_tasks_completed{false};
    std::atomic<unsigned> completion_count{};
    std::future<void> task_futures[16];
    std::atomic<unsigned> outstanding_task_count{16};
    // Lancer plusieurs tâches qui prennent différentes durées
    // puis décrémenter le compteur de tâches en cours
    for (std::future<void>& task_future : task_futures)
        task_future = std::async([&]
        {
            // Cette pause représente l'exécution d'un vrai travail...
            std::this_thread::sleep_for(50ms);
            ++completion_count;
            --outstanding_task_count;
            // Quand le compteur atteint zéro, notifier
            // l'attente (thread principal dans ce cas)
            if (outstanding_task_count.load() == 0)
            {
                all_tasks_completed = true;
                all_tasks_completed.notify_one();
            }
        });
    all_tasks_completed.wait(false);
    std::cout << "Tâches complétées = " << completion_count.load() << '\n';
}

Tâches complétées = 16

Voir aussi