std::atomic_flag::test_and_set

Parameters

sync

Synchronization mode for the operation.
This can be any of the possible values of the enum type memory_order:

value	memory order	description
memory_order_relaxed	Relaxed	No synchronization of side effects.
memory_order_consume	Consume	Synchronizes the visible side effects on values carrying dependencies from the last release or sequentially consistent operation.
memory_order_acquire	Acquire	Synchronizes all visible side effects from the last release or sequentially consistent operation.
memory_order_release	Release	Synchronizes side effects with the next consume or acquire operation.
memory_order_acq_rel	Acquire/Release	Reads as an acquire operation and writes as a release operation (as described above).
memory_order_seq_cst	Sequentially consistent	Synchronizes all visible side effects with the other sequentially consistent operations, following a single total order.

Return value

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// atomic_flag as a spinning lock
#include <iostream>       // std::cout
#include <atomic>         // std::atomic_flag
#include <thread>         // std::thread
#include <vector>         // std::vector
#include <sstream>        // std::stringstream

std::atomic_flag lock_stream = ATOMIC_FLAG_INIT;
std::stringstream stream;

void append_number(int x) {
  while (lock_stream.test_and_set()) {}
  stream << "thread #" << x << '\n';
  lock_stream.clear();
}

int main ()
{
  std::vector<std::thread> threads;
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(append_number,i));
  for (auto& th : threads) th.join();

  std::cout << stream.str();
  return 0;
}

thread #1
thread #2
thread #3
thread #4
thread #5
thread #6
thread #7
thread #8
thread #9
thread #10

Data races

Exception safety

See also

atomic_flag::clear

Clear flag (public member function)

ATOMIC_FLAG_INIT

Initialization of atomic flag (macro)