std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit
From cppreference.com
                    
                                        
                    
                    
                                                            
                    | Defined in header  <atomic> | ||
| (1) | (since C++11) | |
| bool atomic_flag_test_and_set( volatile std::atomic_flag* p ); | ||
| bool atomic_flag_test_and_set( std::atomic_flag* p ); | ||
| (2) | (since C++11) | |
| bool atomic_flag_test_and_set_explicit( volatile std::atomic_flag* p,  std::memory_order order ); | ||
| bool atomic_flag_test_and_set_explicit( std::atomic_flag* p,  std::memory_order order ); | ||
Atomically changes the state of a std::atomic_flag pointed to by p to set (true) and returns the value it held before. 
| Contents | 
[edit] Parameters
| p | - | pointer to std::atomic_flag to access | 
| order | - | the memory synchronization order for this operation | 
[edit] Return value
The value previously held by the flag pointed to by p
[edit] Exceptions
noexcept specification:  
noexcept
  [edit] Possible implementation
| First version | 
|---|
| bool atomic_flag_test_and_set(volatile std::atomic_flag* p) { return p->test_and_set(); } | 
| Second version | 
| bool atomic_flag_test_and_set(std::atomic_flag* p) { return p->test_and_set(); } | 
| Third version | 
| bool atomic_flag_test_and_set_explicit(volatile std::atomic_flag* p, std::memory_order order) { return p->test_and_set(order); } | 
| Fourth version | 
| bool atomic_flag_test_and_set_explicit(std::atomic_flag* p, std::memory_order order) { return p->test_and_set(order); } | 
[edit] Example
A spinlock mutex can be implemented in userspace using an atomic_flag
Run this code
#include <thread> #include <vector> #include <iostream> #include <atomic> std::atomic_flag lock = ATOMIC_FLAG_INIT; void f(int n) { for (int cnt = 0; cnt < 100; ++cnt) { while(std::atomic_flag_test_and_set_explicit(&lock, std::memory_order_acquire)) ; // spin until the lock is acquired std::cout << "Output from thread " << n << '\n'; std::atomic_flag_clear_explicit(&lock, std::memory_order_release); } } int main() { std::vector<std::thread> v; for (int n = 0; n < 10; ++n) { v.emplace_back(f, n); } for (auto& t : v) { t.join(); } }
Output:
Output from thread 2 Output from thread 6 Output from thread 7 ...<exactly 1000 lines>...
[edit] See also
| (C++11) | the lock-free boolean atomic type (class) | 
| (C++11)(C++11) | atomically sets the value of the flag to false (function) | 
| (C++11) | defines memory ordering constraints for the given atomic operation (typedef) | 
| C documentation for atomic_flag_test_and_set, atomic_flag_test_and_set_explicit | |


