Namespaces
Variants
Actions

std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit

From cppreference.com
< cpp‎ | atomic
 
 
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
(C++11)
(C++11)
(C++11)
(C++11)
Condition variables
(C++11)
Semaphores
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
Safe Reclamation
Hazard Pointers
Atomic types
(C++11)
(C++20)
Initialization of atomic types
(C++11)(deprecated in C++20)
(C++11)(deprecated in C++20)
Memory ordering
(C++11)(deprecated in C++26)
Free functions for atomic operations
Free functions for atomic flags
atomic_flag_test_and_setatomic_flag_test_and_set_explicit
(C++11)(C++11)
 
Defined in header <atomic>
bool atomic_flag_test_and_set(volatilestd::atomic_flag* obj )noexcept;
(1) (since C++11)
bool atomic_flag_test_and_set(std::atomic_flag* obj )noexcept;
(2) (since C++11)
bool atomic_flag_test_and_set_explicit(volatilestd::atomic_flag* obj,
                                        std::memory_order order )noexcept;
(3) (since C++11)
bool atomic_flag_test_and_set_explicit(std::atomic_flag* obj,
                                        std::memory_order order )noexcept;
(4) (since C++11)

Atomically changes the state of a std::atomic_flag pointed to by obj to set (true) and returns the value it held before.

1,2) The memory synchronization order is std::memory_order_seq_cst.
3,4) The memory synchronization order is order.

Contents

[edit]Parameters

obj - pointer to std::atomic_flag to access
order - the memory synchronization order

[edit]Return value

The value previously held by the flag pointed to by obj.

[edit]Notes

std::atomic_flag_test_and_set and std::atomic_flag_test_and_set_explicit can be implemented as obj->test_and_set() and obj->test_and_set(order) respectively.

[edit]Example

A spinlock mutex can be implemented in userspace using an std::atomic_flag.

#include <atomic>#include <iostream>#include <thread>#include <vector>   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 acquiredstd::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

the lock-free boolean atomic type
(class)[edit]
atomically sets the value of the flag to false
(function)[edit]
defines memory ordering constraints for the given atomic operation
(enum)[edit]
C documentation for atomic_flag_test_and_set, atomic_flag_test_and_set_explicit
close