std::atomic<T>:: wait

Führt atomare Warteoperationen aus. Verhält sich so, als würden wiederholt die folgenden Schritte ausgeführt:

• Vergleiche die Wertdarstellung von this - > load ( order ) mit der von old .
  • Falls diese gleich sind, blockiert bis * this durch notify_one() oder notify_all() benachrichtigt wird oder der Thread spurios entblockt wird.
  • Andernfalls wird zurückgekehrt.

Diese Funktionen garantieren, dass sie nur zurückkehren, wenn sich der Wert geändert hat, selbst wenn die zugrundeliegende Implementierung fälschlicherweise entblockt.

Wenn order nicht std:: memory_order_relaxed , std:: memory_order_consume , std:: memory_order_acquire oder std:: memory_order_seq_cst ist, ist das Verhalten undefiniert.

Parameter

Hinweise

Diese Form der Änderungserkennung ist oft effizienter als einfaches Polling oder reine Spinlocks.

Aufgrund des ABA-Problems können vorübergehende Änderungen von old zu einem anderen Wert und zurück zu old übersehen werden und nicht freigegeben werden.

Der Vergleich erfolgt bitweise (ähnlich wie std::memcmp ); es wird kein Vergleichsoperator verwendet. Padding-Bits, die niemals an der Wertdarstellung eines Objekts teilnehmen, werden ignoriert.

Beispiel

#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};
    // Spawn several tasks which take different amounts of
    // time, then decrement the outstanding task count.
    for (std::future<void>& task_future : task_futures)
        task_future = std::async([&]
        {
            // This sleep represents doing real work...
            std::this_thread::sleep_for(50ms);
            ++completion_count;
            --outstanding_task_count;
            // When the task count falls to zero, notify
            // the waiter (main thread in this case).
            if (outstanding_task_count.load() == 0)
            {
                all_tasks_completed = true;
                all_tasks_completed.notify_one();
            }
        });
    all_tasks_completed.wait(false);
    std::cout << "Tasks completed = " << completion_count.load() << '\n';
}

Tasks completed = 16

Siehe auch