std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit function in C++

14 May 2025 | 4 min read

The std::atomic_flag_test_and_set and std::atomic_flag_test_and_set_explicit functions in C++ are part of the <atomic> library and are fundamental in implementing lock-free, thread-safe operations. These functions operate on a std::atomic_flag, which is a simple atomic type designed explicitly for boolean flags with two possible states: set and clear. This is useful for implementing basic spinlocks.

std::atomic_flag_test_and_set:

Purpose: This function is used to check if the flag is currently set (true), and if not, it sets the flag. This all happens atomically, which means that once one thread modifies the flag, no other thread can do so simultaneously. This is essential for ensuring that the function's operations are thread-safe.

Usage: flag.test_and_set()

Return Value: It returns the previous value of the flag (either true or false). If the flag is already set, the function will return true. If it is clear, it will set the flag to true and return false.

Example Use Case: A typical use case for std::atomic_flag_test_and_set is in a spinlock. A thread can repeatedly call test_and_set in a loop, waiting until the function returns false, indicating that it successfully set the flag and "locked" the resource.

Example Code:

Output:

 
In critical section
In critical section

Explanation:

In this example, test_and_set is used to acquire a lock. If the flag is already set, it keeps looping (spinning) until another thread clears the flag. When the critical section finishes, lock_flag.clear() releases the lock, allowing other threads to enter.

std::atomic_flag_test_and_set_explicit

Purpose: The std::atomic_flag_test_and_set_explicit is a more advanced version of test_and_set, allowing the programmer to specify the memory ordering. Memory ordering affects how operations on the flag are perceived across different threads, which can impact performance and correctness in multithreaded programs.

Usage: flag.test_and_set_explicit(order)

Parameters:

Order: This is the memory order for the operation, and it can be one of several options:
std::memory_order_relaxed: No synchronization or ordering constraints.
std::memory_order_acquire: Ensures that operations after the acquire in the current thread are not moved before it.
std::memory_order_release: Ensures that all operations before the release in the current thread are not moved after it.
std::memory_order_acq_rel: Both acquire and release semantics.
std::memory_order_seq_cst: Ensures sequential consistency among threads.

Return Value: Like test_and_set, it returns the previous state of the flag (true if it was already set, false if it was clear).

Example Code:

Key differences between std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit function in C++:

Some main differences between these functions are as follows:

Feature	atomic_flag_test_and_set	atomic_flag_test_and_set_explicit
Purpose	Atomically checks if the flag is set and, if not, sets it to true. Used primarily in simple synchronization tasks like basic spinlocks or mutex implementations.	Atomically checks and sets the flag, with the option to specify memory ordering, making it suitable for more controlled and complex multithreaded tasks.
Memory Ordering	Uses the default memory ordering, which is usually std::memory_order_seq_cst (sequential consistency), ensuring the most restrictive ordering to keep operations visible to all threads in order.	Allows specifying a memory ordering, providing more control over visibility and reordering of operations for fine-grained performance tuning.
Return Value	Returns the previous state of the flag (true if it was already set, false if it was clear and is now set).	Returns the previous state of the flag (true if already set, false if clear and just set), providing an atomic test-and-set with more control over memory effects.
Common Use Case	Ideal for basic synchronization needs, such as implementing a simple spinlock, where one thread must "lock" a resource while other threads wait. For example, while a thread is in a critical section, other threads spin until the lock is released.	Suited for more advanced scenarios where explicit memory ordering is crucial for performance, such as high-performance concurrent data structures or low-level synchronization mechanisms where memory visibility needs to be precisely managed.
Syntax	flag.test_and_set()	flag.test_and_set_explicit(order)
Memory Order Options	Implicit, typically std::memory_order_seq_cst, which provides a strong guarantee of sequential consistency but may have a performance cost in high-frequency access patterns.	Accepts specific memory ordering arguments, such as: <ul><li>std::memory_order_relaxed - Minimal synchronization, only atomicity.</li><li>std::memory_order_acquire - Ensures no reads or writes can be reordered before this operation in the current thread.</li><li>std::memory_order_release - Ensures no reads or writes can be reordered after this operation in the current thread.</li><li>std::memory_order_acq_rel - Combines acquire and release semantics.</li><li>std::memory_order_seq_cst - Ensures all operations maintain sequential consistency across all threads.</li></ul>
Performance Implications	Less flexibility in terms of reordering and visibility, potentially introducing overhead in high-performance applications where looser ordering may suffice.	It allows optimization by choosing memory ordering best suited to the use case. For example, using memory_order_relaxed can enhance performance by avoiding unnecessary ordering constraints.
Example Usage	Basic spinlock example: cpp<br>while (flag.test_and_set()) { /* spin */ }<br>// Critical section<br>flag.clear();	Spinlock with explicit memory ordering: cpp<br>while (flag.test_and_set_explicit(std::memory_order_acquire)) { /* spin */ }<br>// Critical section<br>flag.clear(std::memory_order_release);
When to Use	Suitable when robust synchronization is required without needing fine-tuned performance control. Ideal for general-purpose tasks that rely on standard memory ordering.	Recommended when specific memory ordering requirements are needed for performance tuning or when working on low-level optimizations where managing reordering or memory visibility can benefit overall efficiency.

Next TopicDifferent Ways to Convert Vector to Array in C++ STL

← prev next →

std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit function in C++