std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

<metanoindex/>

 

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)

 

<tbody> </tbody>

Определено в заголовочном файле <atomic>
template< class T > bool atomic_compare_exchange_weak( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, T* expected, T desired );	(1)	(начиная с C++11)
template< class T > bool atomic_compare_exchange_strong( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj, T* expected, T desired );	(2)	(начиная с C++11)
template< class T > bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );	(3)	(начиная с C++11)
template< class T > bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );	(4)	(начиная с C++11)

Атомарно сравнивает значение указывает obj со значением, на которое указывает expected, и если эти равны, заменяет бывший с desired (выполняет чтение-модификация-запись). В противном случае, загружает текущее значение указывает obj в *expected (выполняет операцию загрузки).

Оригинал:

Atomically compares the value pointed to by obj with the value pointed to by expected, and if those are equal, replaces the former with desired (performs read-modify-write operation). Otherwise, loads the actual value pointed to by obj into *expected (performs load operation).

Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Модели памяти для чтения-модификации-записи и загрузки операций succ и fail соответственно. (1-2) версии используют std::memory_order_seq_cst по умолчанию.

Оригинал:

The memory models for the read-modify-write and load operations are succ and fail respectively. The (1-2) versions use std::memory_order_seq_cst by default.

Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Слабые формы ((1) и (3)) функции могут потерпеть неудачу ложно, то есть действовать, как если *obj != *expected, даже если они равны. Когда сравнения и обмена в цикле, слабая версия даст лучшую производительность на некоторых платформах. При слабом сравнения и обмена потребует петли и сильный не будет, сильный предпочтительнее.

Оригинал:

The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if *obj != *expected even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.

Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Эти функции определены в терминах функций-членов std::atomic

Оригинал:

These functions are defined in terms of member functions of std::atomic:

Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

1) obj->compare_exchange_weak(exp, desr)

2) obj->compare_exchange_strong(exp, desr)

3) obj->compare_exchange_weak(exp, desr, succ, fail)

4) obj->compare_exchange_strong(exp, desr, succ, fail)

Параметры

obj	—	Указатель на атомном объекте проверить и изменить Оригинал: pointer to the atomic object to test and modify Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
expected	—	указатель на значение как ожидается, будет найден в атомном объекте Оригинал: pointer to the value expected to be found in the atomic object Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
desired	—	значение для хранения в атомном объекте, если он, как ожидается Оригинал: the value to store in the atomic object if it is as expected Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
succ	—	памяти sycnhronization заказа на чтение-модификация-запись, если сравнение успешно. Все допустимые значения . Оригинал: the memory sycnhronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
fail	—	памяти sycnhronization заказа для операции загрузки, если сравнение не удается. Не может быть std::memory_order_release или std::memory_order_ack_rel и не может указать порядок сильнее, чем succ Оригинал: the memory sycnhronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_ack_rel and cannot specify stronger ordering than succ Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Возвращаемое значение

Результат сравнения: true если *obj составила *exp, false иначе.

Оригинал:

The result of the comparison: true if *obj was equal to *exp, false otherwise.

Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Исключения

спецификация noexcept:  

noexcept

  

Пример

Этот пример показывает, как сравнения и обмена может быть использован для реализации блокировки бесплатного добавления к однонаправленного списка

Оригинал:

This example shows how compare-and-exchange may be used to implement lock-free append to a singly linked list

Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

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

void append(list* s, node* n)
{
    node* head;
    do {
        head = s->head;
        n->next = head;
    } while(! std::atomic_compare_exchange_weak(s->head, head, n));
}

См. также

compare_exchange_weakcompare_exchange_strong	атомарно сравнивает значение атомарного объекта с неатомарным аргументом и выполняет атомарный обмен, если они равны, или атомарную загрузку, если нет (public функция-элемент std::atomic)
atomic_exchangeatomic_exchange_explicit (C++11)(C++11)	атомарно заменяет значение атомарного объекта неатомарным аргументом и возвращает предыдущее атомарное значение (шаблон функции)
std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr)	Специализируется атомарных операций на ЗППП :: shared_ptr Оригинал: specializes atomic operations for std::shared_ptr Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции)
Документация C по atomic_compare_exchange, atomic_compare_exchange_explicit