public member function

std::atomic_flag::clear

void clear (memory_order sync = memory_order_seq_cst) volatile noexcept;void clear (memory_order sync = memory_order_seq_cst) noexcept;

Clear flag

Clears the atomic_flag (i.e., sets it to false).

Clearing the atomic_flag makes the next call to member atomic_flag::test_and_set on this object return false.

The operation is atomic and follows the memory ordering specified by sync.

Parameters

sync

Synchronization mode for the operation.
This can be any of the following 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_seq_cst`	Sequentially consistent	Synchronizes all visible side effects with the other sequentially consistent operations, following a single total order.

value	memory order	description
`memory_order_relaxed`	Relaxed	No synchronization of side effects.
`memory_order_release`	Release	Synchronizes side effects with the next consume or acquire operation.
`memory_order_seq_cst`	Sequentially consistent	Synchronizes all visible side effects with the other sequentially consistent operations, following a single total order.

Return value

none

Example

// 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;
}

Edit & run on cpp.sh

Possible output (order of lines may vary):

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

Data races

No data races (atomic operation). Memory order specified by argument sync.

Exception safety

No-throw guarantee: never throws exceptions.

classes

enum types

functions

initialization macros

functions (C-style atomics)