std::atomic

Определено в заголовочном файле `<atomic>`
`template< class T > struct atomic;`	(1)	(начиная с C++11)
`template< class U > struct atomic<U*>;`	(2)	(начиная с C++11)
Определено в заголовочном файле `<memory>`
`template< class U > struct atomic<std::shared_ptr<U>>;`	(3)	(начиная с C++20)
`template< class U > struct atomic<std::weak_ptr<U>>;`	(4)	(начиная с C++20)
Определено в заголовочном файле `<stdatomic.h>`
`#define _Atomic(T) /* смотрите ниже */`	(5)	(начиная с C++23)

Каждое инстанцирование и полная специализация шаблона std::atomic определяет атомарный тип. Если один поток записывает в атомарный объект, а другой поток читает из него, поведение чётко определено (подробности о гонках данных смотрите в модели памяти.

Кроме того, доступ к атомарным объектам может установить межпотоковую синхронизацию и упорядочить доступ к неатомарной памяти, как указано в std::memory_order.

std::atomic нельзя ни копировать, ни перемещать.

Макрос совместимости _Atomic предоставляется в <stdatomic.h>, так что _Atomic(T) идентичен std::atomic<T> пока оба правильно сформированы.

Не указано, доступно ли какое-либо объявление в пространстве имён std, когда включен <stdatomic.h>.

(начиная с C++23)

Специализации

Основной шаблон

Основной шаблон std::atomic может быть создан с любым TriviallyCopyable типом T, соответствующим и CopyConstructible и CopyAssignable. Программа некорректна, если любое из следующих значений false:

std::is_trivially_copyable<T>::value
std::is_copy_constructible<T>::value
std::is_move_constructible<T>::value
std::is_copy_assignable<T>::value
std::is_move_assignable<T>::value

struct Counters { int a; int b; }; // определённый пользователем тип,
                                   // допускающий тривиальное копирование
std::atomic<Counters> cnt;         // специализация для определённого пользователем типа

std::atomic<bool> использует основной шаблон. Гарантируется, что это будет структура со стандартным выравниванием.

Частичные специализации

Стандартная библиотека предоставляет частичную специализацию шаблона std::atomic для следующих типов с дополнительными свойствами, которых нет у основного шаблона:

2) Частичные специализации std::atomic<U*> для всех типов указателей. Эти специализации имеют стандартное выравнивание, тривиальные конструкторы по умолчанию, (до C++20) и тривиальные деструкторы. Помимо операций, предусмотренных для всех атомарных типов, эти специализации дополнительно поддерживают атомарные арифметические операции, соответствующие типам указателей, такие как fetch_add, fetch_sub.

3,4) Частичные специализации std::atomic<std::shared_ptr<U>> и std::atomic<std::weak_ptr<U>> предусмотрены для std::shared_ptr и std::weak_ptr.

Для подробной информации смотрите std::atomic<std::shared_ptr> и std::atomic<std::weak_ptr>.

(начиная с C++20)

Специализации для целочисленных типов

При создании экземпляра с одним из следующих целых типов std::atomic предоставляет дополнительные атомарные операции, соответствующие целочисленным типам, такие как fetch_add, fetch_sub, fetch_and, fetch_or, fetch_xor:

Символьные типы char, char8_t (начиная с C++20), char16_t, char32_t и wchar_t;
Стандартные целочисленные типы со знаком: signed char, short, int, long и long long;
Стандартные целочисленные типы без знака: unsigned char, unsigned short, unsigned int, unsigned long и unsigned long long;
Любые дополнительные целочисленные типы, необходимые для typedef‘ов в заголовке <cstdint>.

Кроме того, получившаяся специализация std::atomic<Целочисленный тип> имеет стандартное выравнивание, тривиальный конструктор по умолчанию, (до C++20) и тривиальный деструктор. Знаковая целочисленная арифметика использует дополнение до двух; нет неопределённых результатов.

Специализации для типов с плавающей запятой

При создании экземпляра с одним из cv-неквалифицированных типов с плавающей запятой (float, double и long double и cv-неквалифицированные расширенные типы с плавающей запятой (начиная с C++23)), std::atomic предоставляет дополнительные атомарные операции, подходящие для типов с плавающей запятой, такие как fetch_add и fetch_sub.

Кроме того, получившаяся специализация std::atomic<Тип с плавающей запятой> имеет стандартное выравнивание и тривиальный деструктор.

Никакие операции не приводят к неопределённому поведению, даже если результат не представляется в виде типа с плавающей запятой. Фактически среда с плавающей запятой может отличаться от среды с плавающей запятой вызывающего потока.

(начиная с C++20)

Псевдонимы типов

Для bool и всех перечисленных выше целочисленных типов предусмотрены следующие псевдонимы типов:

Псевдонимы для всех `std::atomic<Целочисленный тип>`
atomic_bool (C++11)	`std::atomic<bool>` (определение типа) [править]
atomic_char (C++11)	`std::atomic<char>` (определение типа) [править]
atomic_schar (C++11)	`std::atomic<signed char>` (определение типа) [править]
atomic_uchar (C++11)	`std::atomic<unsigned char>` (определение типа) [править]
atomic_short (C++11)	`std::atomic<short>` (определение типа) [править]
atomic_ushort (C++11)	`std::atomic<unsigned short>` (определение типа) [править]
atomic_int (C++11)	`std::atomic<int>` (определение типа) [править]
atomic_uint (C++11)	`std::atomic<unsigned int>` (определение типа) [править]
atomic_long (C++11)	`std::atomic<long>` (определение типа) [править]
atomic_ulong (C++11)	`std::atomic<unsigned long>` (определение типа) [править]
atomic_llong (C++11)	`std::atomic<long long>` (определение типа) [править]
atomic_ullong (C++11)	`std::atomic<unsigned long long>` (определение типа) [править]
atomic_char8_t (C++20)	`std::atomic<char8_t>` (определение типа) [править]
atomic_char16_t (C++11)	`std::atomic<char16_t>` (определение типа) [править]
atomic_char32_t (C++11)	`std::atomic<char32_t>` (определение типа) [править]
atomic_wchar_t (C++11)	`std::atomic<wchar_t>` (определение типа) [править]
atomic_int8_t (C++11)(необязательно)	`std::atomic<std::int8_t>` (определение типа) [править]
atomic_uint8_t (C++11)(необязательно)	`std::atomic<std::uint8_t>` (определение типа) [править]
atomic_int16_t (C++11)(необязательно)	`std::atomic<std::int16_t>` (определение типа) [править]
atomic_uint16_t (C++11)(необязательно)	`std::atomic<std::uint16_t>` (определение типа) [править]
atomic_int32_t (C++11)(необязательно)	`std::atomic<std::int32_t>` (определение типа) [править]
atomic_uint32_t (C++11)(необязательно)	`std::atomic<std::uint32_t>` (определение типа) [править]
atomic_int64_t (C++11)(необязательно)	`std::atomic<std::int64_t>` (определение типа) [править]
atomic_uint64_t (C++11)(необязательно)	`std::atomic<std::uint64_t>` (определение типа) [править]
atomic_int_least8_t (C++11)	`std::atomic<std::int_least8_t>` (определение типа) [править]
atomic_uint_least8_t (C++11)	`std::atomic<std::uint_least8_t>` (определение типа) [править]
atomic_int_least16_t (C++11)	`std::atomic<std::int_least16_t>` (определение типа) [править]
atomic_uint_least16_t (C++11)	`std::atomic<std::uint_least16_t>` (определение типа) [править]
atomic_int_least32_t (C++11)	`std::atomic<std::int_least32_t>` (определение типа) [править]
atomic_uint_least32_t (C++11)	`std::atomic<std::uint_least32_t>` (определение типа) [править]
atomic_int_least64_t (C++11)	`std::atomic<std::int_least64_t>` (определение типа) [править]
atomic_uint_least64_t (C++11)	`std::atomic<std::uint_least64_t>` (определение типа) [править]
atomic_int_fast8_t (C++11)	`std::atomic<std::int_fast8_t>` (определение типа) [править]
atomic_uint_fast8_t (C++11)	`std::atomic<std::uint_fast8_t>` (определение типа) [править]
atomic_int_fast16_t (C++11)	`std::atomic<std::int_fast16_t>` (определение типа) [править]
atomic_uint_fast16_t (C++11)	`std::atomic<std::uint_fast16_t>` (определение типа) [править]
atomic_int_fast32_t (C++11)	`std::atomic<std::int_fast32_t>` (определение типа) [править]
atomic_uint_fast32_t (C++11)	`std::atomic<std::uint_fast32_t>` (определение типа) [править]
atomic_int_fast64_t (C++11)	`std::atomic<std::int_fast64_t>` (определение типа) [править]
atomic_uint_fast64_t (C++11)	`std::atomic<std::uint_fast64_t>` (определение типа) [править]
atomic_intptr_t (C++11)(необязательно)	`std::atomic<std::intptr_t>` (определение типа) [править]
atomic_uintptr_t (C++11)(необязательно)	`std::atomic<std::uintptr_t>` (определение типа) [править]
atomic_size_t (C++11)	`std::atomic<std::size_t>` (определение типа) [править]
atomic_ptrdiff_t (C++11)	`std::atomic<std::ptrdiff_t>` (определение типа) [править]
atomic_intmax_t (C++11)	`std::atomic<std::intmax_t>` (определение типа) [править]
atomic_uintmax_t (C++11)	`std::atomic<std::uintmax_t>` (определение типа) [править]
Псевдонимы для специальных типов
atomic_signed_lock_free (C++20)	знаковый целочисленный атомарный тип, который свободен от блокировок и для которого ожидание/уведомление является наиболее эффективным (определение типа) [править]
atomic_unsigned_lock_free (C++20)	беззнаковый целочисленный атомарный тип, который свободен от блокировок и для которого ожидание/уведомление является наиболее эффективным (определение типа) [править]

Примечание: std::atomic_intN_t, std::atomic_uintN_t, std::atomic_intptr_t и std::atomic_uintptr_t определены тогда и только тогда, когда std::intN_t, std::uintN_t, std::intptr_t и std::uintptr_t определены соответственно.

std::atomic_signed_lock_free и std::atomic_unsigned_lock_free не обязательны в автономных реализациях.

(начиная с C++20)

Типы-элементы


Тип элемент	Определение
`value_type`	`T` (независимо от того, специализирован или нет)
`difference_type`	`value_type` (только для специализаций `atomic<Целочисленный тип>` и `atomic<Тип с плавающей запятой>` (начиная с C++20)) std::ptrdiff_t (только для специализаций `std::atomic<U*>`)

difference_type не определён в основном шаблоне std::atomic или в частичных специализациях для std::shared_ptr и std::weak_ptr.

Функции-элементы

(конструктор)	создаёт атомарный объект (public функция-элемент) [править]
operator=	сохраняет значение в атомарном объекте (public функция-элемент) [править]
is_lock_free	проверяет, свободен ли атомарный объект от блокировки (public функция-элемент) [править]
store (C++11)	атомарно заменяет значение атомарного объекта неатомарным аргументом (public функция-элемент) [править]
load	атомарно получает значение атомарного объекта (public функция-элемент) [править]
operator T	загружает значение из атомарного объекта (public функция-элемент) [править]
exchange	атомарно заменяет значение атомарного объекта и получает ранее сохранённое значение (public функция-элемент) [править]
compare_exchange_weakcompare_exchange_strong	атомарно сравнивает значение атомарного объекта с неатомарным аргументом и выполняет атомарный обмен, если они равны, или атомарную загрузку, если нет (public функция-элемент) [править]
wait	блокирует поток до тех пор, пока не получит уведомление и не изменится атомарное значение (public функция-элемент) [править]
notify_one	уведомляет хотя бы один поток, ожидающий атомарный объект (public функция-элемент) [править]
notify_all	уведомляет все потоки, заблокированные в ожидании атомарного объекта (public функция-элемент) [править]
Константы
is_always_lock_free [static] (C++17)	указывает, что тип всегда свободен от блокировок (public static константа-элемент) [править]

Специализированные функции-элементы

fetch_add	атомарно добавляет аргумент к значению, хранящемуся в атомарном объекте, и получает значение, сохранённое ранее (public функция-элемент) [править]
fetch_sub	атомарно вычитает аргумент из значения, хранящегося в атомарном объекте, и получает значение, сохранённое ранее (public функция-элемент) [править]
fetch_and	атомарно выполняет побитовое И между аргументом и значением атомарного объекта и получает значение, сохранённое ранее (public функция-элемент) [править]
fetch_or	атомарно выполняет побитовое ИЛИ между аргументом и значением атомарного объекта и получает значение, сохранённое ранее (public функция-элемент) [править]
fetch_xor	атомарно выполняет побитовое исключающее ИЛИ между аргументом и значением атомарного объекта и получает значение, сохранённое ранее (public функция-элемент) [править]
operator++operator++(int)operator--operator--(int)	увеличивает или уменьшает атомарное значение на единицу (public функция-элемент) [править]
operator+=operator-=operator&=operator\|=operator^=	добавляет, вычитает или выполняет побитовое И, ИЛИ, исключающее ИЛИ с атомарным значением (public функция-элемент) [править]

Примечание

Существуют эквиваленты шаблонов функций, не являющихся элементами, для всех функций-элементов std::atomic. Эти функции, не являющиеся элементами, могут быть дополнительно перегружены для типов, которые не являются специализациями std::atomic, но могут гарантировать атомарность. Единственный такой тип в стандартной библиотеке это std::shared_ptr<U>.

_Atomic это ключевое слово и используется для предоставления атомарных типов в C.

Реализации рекомендуются для обеспечения того, чтобы представление _Atomic(T) в C было таким же, как представление std::atomic<T> в C++ для каждого возможного типа T. Механизмы, используемые для обеспечения атомарности и упорядочивания памяти, должны быть совместимы.

В gcc и clang некоторые функции, описанные здесь, требуют связывания с -latomic.

Пример

Запустить этот код

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

std::atomic_int acnt;
int cnt;

void f()
{
    for(int n = 0; n < 10000; ++n)
    {
        ++acnt;
        ++cnt;
        // Примечание: для этого примера достаточно ослабленно упопорядоченной памяти,
        // например, acnt.fetch_add(1, std::memory_order_relaxed);
    }
}

int main()
{
  {
    std::vector<std::jthread> pool;
    for(int n = 0; n < 10; ++n)
        pool.emplace_back(f);
  }

  std::cout << "Атомарный счётчик равен " << acnt << '\n'
            << "Неатомарный счётчик равен " << cnt << '\n';
}

Возможный вывод:

Атомарный счётчик равен 100000
Неатомарный счётчик равен 69696

Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 2441	c++11	typedef'фы для атомарных версий необязательных целочисленных типов фиксированной ширины отсутствовали	добавлены
LWG 3012	c++11	`std::atomic<T>` был разрешён для любых `T`, которые можно копировать только тривиально	такие специализации запрещены
WG не указан	c++11	вывод аргументов шаблона для некоторых функций для атомарных типов может случайно вызвать ошибку; были предоставлены недопустимые операции с указателями	спецификация была существенно переписана: добавлены определения типов элементов `value_type` и `difference_type`

Смотрите также

atomic_flag (C++11)	свободный от блокировок логический атомарный тип (класс) [править]
std::atomic<std::shared_ptr> (C++20)	атомарный разделяемый указатель (специализация шаблона класса) [править]
std::atomic<std::weak_ptr> (C++20)	атомарный слабый указатель (специализация шаблона класса) [править]
Документация C по Атомарные типы

Поддержка компилятором
Автономные и размещённые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Требования к именованию
Макросы тестирования функциональности (C++20)
Поддержка языка
Библиотека концептов (C++20)
Библиотека метапрограммирования (C++11)
Библиотека диагностики
Библиотека общих утилит
Библиотека строк
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека численных данных
Библиотека ввода/вывода
Библиотека локализаций
Регулярные выражения (C++11)
Атомарные операции (C++11)
Библиотека поддержки конкуренции (C++11)
Библиотека файловой системы (C++17)
Технические спецификации
Указатель символов
Внешние библиотеки

Типы
atomic (C++11)
atomic_ref (C++20)
Функции
atomic_storeatomic_store_explicit (C++11)(C++11)
atomic_loadatomic_load_explicit (C++11)(C++11)
atomic_exchangeatomic_exchange_explicit (C++11)(C++11)
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11)
atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11)
atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11)
atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11)
atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11)
atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11)
atomic_is_lock_free (C++11)
atomic_waitatomic_wait_explicit (C++20)(C++20)
atomic_notify_one (C++20)
atomic_notify_all (C++20)
Атомарные флаги
atomic_flag (C++11)
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)
atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)
atomic_flag_testatomic_flag_test_explicit (C++20)(C++20)
atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20)
atomic_flag_notify_one (C++20)
atomic_flag_notify_all (C++20)
Инициализация
atomic_init (C++11)(устарело в C++20)
ATOMIC_VAR_INIT (C++11)(устарело в C++20)
ATOMIC_FLAG_INIT (C++11)(устарело в C++20)
Упорядочивание доступа к памяти
memory_order (C++11)
kill_dependency (C++11)
atomic_thread_fence (C++11)
atomic_signal_fence (C++11)

Функции-элементы
atomic::atomic
atomic::operator=
atomic::is_lock_free
atomic::store
atomic::load
atomic::operator T
atomic::exchange
atomic::compare_exchange_strongatomic::compare_exchange_weak
atomic::wait (C++20)
atomic::notify_one (C++20)
atomic::notify_all (C++20)
Константы
atomic::is_always_lock_free (C++17)
Специализированные функции-элементы
atomic::fetch_add
atomic::fetch_sub
atomic::fetch_and
atomic::fetch_or
atomic::fetch_xor
atomic::operator++atomic::operator++(int)atomic::operator--atomic::operator--(int)
atomic::operator+=atomic::operator-=atomic::operator&=atomic::operator\|=atomic::operator^=

cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

std::atomic

Содержание

Специализации

Основной шаблон

Частичные специализации

Специализации для целочисленных типов

Специализации для типов с плавающей запятой

Псевдонимы типов

Псевдонимы для всех `std::atomic<Целочисленный тип>`

Псевдонимы для специальных типов

Типы-элементы

Функции-элементы

Константы

Специализированные функции-элементы

Примечание

Пример

Отчёты о дефектах

Смотрите также

Навигация

Инструменты

cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

std::atomic

Специализации

Основной шаблон

Частичные специализации

Специализации для целочисленных типов

Специализации для типов с плавающей запятой

Псевдонимы типов

Псевдонимы для всех std::atomic<Целочисленный тип>

Псевдонимы для специальных типов

Типы-элементы

Функции-элементы

Константы

Специализированные функции-элементы

Примечание

Пример

Отчёты о дефектах

Смотрите также

Навигация

Инструменты

Псевдонимы для всех `std::atomic<Целочисленный тип>`