std::atomic_flag
Von cppreference.com
| Definiert in Header <atomic> |
||
| class atomic_flag; |
(seit C++11) | |
std::atomic_flag ist ein atomarer boolescher Typ. Im Gegensatz zu allen Spezialisierungen von std::atomic ist garantiert, dass er lock-free ist. Im Gegensatz zu std::atomic<bool> bietet std::atomic_flag keine Lese- oder Schreiboperationen.
[bearbeiten] Memberfunktionen
| konstruiert ein atomic_flag (öffentliche Memberfunktion) | |
| [gelöscht] |
der Zuweisungsoperator (gelöscht) (öffentliche Memberfunktion) |
| setzt das Flag atomar auf false (public member function) | |
| setzt das Flag atomar auf true und gibt seinen vorherigen Wert zurück (public member function) | |
| (C++20) |
gibt den Wert des Flags atomar zurück (public member function) |
| (C++20) |
blockiert den Thread, bis er benachrichtigt wird und der atomare Wert sich ändert (public member function) |
| (C++20) |
benachrichtigt mindestens einen Thread, der auf das atomare Objekt wartet (public member function) |
| (C++20) |
benachrichtigt alle Threads, die auf das atomare Objekt warten (public member function) |
[bearbeiten] Beispiel
Ein Spinlock-Mutex kann im Userspace mit einem atomic_flag implementiert werden. Beachten Sie, dass Spinlock-Mutexes in der Praxis äußerst fragwürdig sind.
Führen Sie diesen Code aus
#include <atomic> #include <iostream> #include <mutex> #include <thread> #include <vector> class mutex { std::atomic_flag m_{}; public: void lock() noexcept { while (m_.test_and_set(std::memory_order_acquire)) #if defined(__cpp_lib_atomic_wait) && __cpp_lib_atomic_wait >= 201907L // Since C++20, locks can be acquired only after notification in the unlock, // avoiding any unnecessary spinning. // Note that even though wait guarantees it returns only after the value has // changed, the lock is acquired after the next condition check. m_.wait(true, std::memory_order_relaxed) #endif ; } bool try_lock() noexcept { return !m_.test_and_set(std::memory_order_acquire); } void unlock() noexcept { m_.clear(std::memory_order_release); #if defined(__cpp_lib_atomic_wait) && __cpp_lib_atomic_wait >= 201907L m_.notify_one(); #endif } }; static mutex m; static int out{}; void f(std::size_t n) { for (std::size_t cnt{}; cnt < 40; ++cnt) { std::lock_guard lock{m}; std::cout << n << ((++out % 40) == 0 ? '\n' : ' '); } } int main() { std::vector<std::thread> v; for (std::size_t n{}; n < 10; ++n) v.emplace_back(f, n); for (auto &t : v) t.join(); }
Mögliche Ausgabe
0 1 1 2 0 1 3 2 3 2 0 1 2 3 2 3 0 1 3 2 0 1 2 3 2 3 0 3 2 3 2 3 2 3 1 2 3 0 1 3 2 3 2 0 1 2 3 0 1 2 3 2 0 1 2 3 0 1 2 3 2 3 2 3 2 0 1 2 3 2 3 0 1 3 2 3 0 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 3 2 0 2 3 2 3 2 3 2 3 2 3 0 3 2 3 0 3 0 3 2 3 0 3 2 3 2 3 0 2 3 0 3 2 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9
[bearbeiten] Siehe auch
| setzt das Flag atomar auf true und gibt seinen vorherigen Wert zurück (Funktion) | |
| (C++11)(C++11) |
setzt den Wert des Flags atomar auf false (Funktion) |
| (C++20)(C++20) |
blockiert den Thread, bis er benachrichtigt wird und sich das Flag ändert (Funktion) |
| (C++20) |
benachrichtigt einen Thread, der in atomic_flag_wait blockiert ist (Funktion) |
| (C++20) |
benachrichtigt alle Threads, die in atomic_flag_wait blockiert sind (Funktion) |
| (C++11) |
initialisiert ein std::atomic_flag auf false (Makro-Konstante) |
| C-Dokumentation für atomic_flag
| |
