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

 

C++

Suporte ao Compilador

Freestanding and hosted

Linguagem

Headers da Biblioteca Standard

Requerimentos nomeados

Feature test macros (C++20)

Biblioteca de suporte de língua

Biblioteca de conceitos(C++20)

Biblioteca de diagnósticos

Biblioteca de utilitários em geral

Biblioteca de strings

Biblioteca de containers

Ranges library(C++20)

Biblioteca de iteradores

Biblioteca de algorítmos

Biblioteca numérica

Biblioteca de localizações

Biblioteca de input/output

Biblioteca de sistema de arquivo(C++17)

Biblioteca de expressões regulares(C++11)

Biblioteca de operações atômicas(C++11)

Biblioteca de suporte de thread(C++11)

Especificações Técnicas

Índice de symbolos

Bibliotecas externas

 

Biblioteca operações atômica

Tipos Original: Types The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic (C++11)

atomic_is_lock_free (C++11)

Funções Original: Functions The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

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)

Bandeiras atômicas Original: Atomic flags The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

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)

Inicialização Original: Initialization The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_init (C++11)

ATOMIC_VAR_INIT (C++11)

ATOMIC_FLAG_INIT (C++11)

Memória de encomenda Original: Memory ordering The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

Definido no cabeçalho <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(volatilestd::atomic<T>* obj,                                    T* expected, T desired );	(1)	(desde 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(volatilestd::atomic<T>* obj,                                      T* expected, T desired );	(2)	(desde 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(volatilestd::atomic<T>* obj,                                             T* expected, T desired,                                             std::memory_order succ,                                             std::memory_order fail );	(3)	(desde 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(volatilestd::atomic<T>* obj,                                               T* expected, T desired,                                               std::memory_order succ,                                               std::memory_order fail );	(4)	(desde C++11)

Atomicamente compara o valor apontado por obj com o valor apontado por expected, e se estas forem iguais, substitui o ex-desired (executa ler-modificar-escrever a operação). Caso contrário, carrega o valor real apontado por obj em *expected (executa a operação de carga).

Original:

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).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Os modelos de memória para a leitura-modificação-gravação e operações de carga são succ e fail respectivamente. As versões (1-2) usar std::memory_order_seq_cst por padrão.

Original:

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.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

As formas fracas ((1) e (3)) das funções podem falhar spuriously, isto é, actuar como se *obj !=*expected mesmo se eles forem iguais. Quando uma comparação e troca-se em um loop, a versão fraca trará melhor desempenho em algumas plataformas. Quando um fraco comparar-e-troca exigiria um laço e um forte não, o forte é preferível.

Original:

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.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Essas funções são definidas em termos de funções de membro de std::atomic:

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

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)

Parâmetros

obj	-	ponteiro para o objeto atômico para testar e modificar Original: pointer to the atomic object to test and modify The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
expected	-	ponteiro para o valor esperado para ser encontrado no objeto atómica Original: pointer to the value expected to be found in the atomic object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
desired	-	o valor para armazenar no objeto atômico se for como o esperado Original: the value to store in the atomic object if it is as expected The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
succ	-	o sycnhronization memória de ordenação para a leitura-modificação-gravação operação, se a comparação for bem-sucedido. Todos os valores são permitidos . Original: the memory sycnhronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
fail	-	o sycnhronization memória de ordenação para a operação de carga se a comparação falhar. Não pode ser std::memory_order_release ou std::memory_order_ack_rel e não pode especificar mais forte do que succ ordenação Original: 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 The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Valor de retorno

O resultado da comparação: true se *obj foi igual a *exp, false contrário.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Exceções

noexcept specification:  

noexcept

  (desde C++11)

Exemplo

Este exemplo mostra como comparar-e-troca pode ser usado para implementar sem bloqueio de acrescentar a uma lista vinculada isoladamente

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

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

Veja também

compare_exchange_weak compare_exchange_strong	atomicamente compara o valor do objeto atômico com não atômica argumento e realiza troca atômica se carga igual ou atômica se não Original: atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (of std::atomic função pública membro)
atomic_exchange atomic_exchange_explicit (C++11) (C++11)	atomicamente substitui o valor do objeto atômico com não atômica argumento e retorna o valor antigo do atômica Original: atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função)
std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr)	especializada operações atômicas para std :: shared_ptr Original: specializes atomic operations for std::shared_ptr The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função)
Documentação C para atomic_compare_exchange, atomic_compare_exchange_explicit