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

 

C++

Язык

Заголовочные файлы

Концепты

Поддержка языка

Ошибка

Утилиты

Строки

Контейнеры

Алгоритмы

Итераторы

Работа с числами

Ввод/вывод

Локализация

Регулярные выражения (C++11)

Атомарные операции (C++11)

Потоки (C++11)

Файловая система (C++17)

Технические спецификации

 

Библиотека атомарных операций

Типы

atomic (C++11)

atomic_is_lock_free (C++11)

Функции

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_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_init (C++11)

ATOMIC_VAR_INIT (C++11)

ATOMIC_FLAG_INIT (C++11)

Упорядочивание доступа к памяти

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

Определён в заголовочном файле <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_weak compare_exchange_strong	атомарно сравнивает значение атомарного объекта с не атомарным аргументом и выполняет атомарный обмен, если равны или атомарную загрузку, если нет Оригинал: atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (public функция-член std::atomic)
atomic_exchange atomic_exchange_explicit (C++11) (C++11)	атомарно заменяет значение атомного объекта с неатомической аргумент и возвращает старое значение атомной Оригинал: atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции)
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