Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::atomic: acesso atómico a um valor partilhado

std::atomic fornece cargas, escritas e operações read-modify-write indivisíveis num objeto com ordem de memória configurável.

Versão: C++23

Sintaxe

template<class T>
struct atomic; // T: non-cv, trivially copyable, copy/move constructible and assignable

// common selected operations
T load(std::memory_order order = std::memory_order_seq_cst) const noexcept;
void store(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept;
bool is_lock_free() const noexcept;
T exchange(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept;

// applicable numeric and pointer specializations additionally provide:
T fetch_add(/* difference type */ operand,
    std::memory_order order = std::memory_order_seq_cst) noexcept;

std::atomic<T>, de <atomic>, fornece as operações comuns load, store, exchange e compare-exchange sobre um valor; a ordem predefinida é std::memory_order_seq_cst. fetch_add não pertence a todos os atomic<T>: só existe nas especializações aplicáveis, incluindo numéricas e de ponteiros. No template primário, T tem de ser trivialmente copiável, construível e atribuível por cópia e movimento, e não pode ter qualificação cv. std::atomic::load efetua uma leitura atómica e não admite ordem release nem acq_rel; std::atomic::store efetua uma escrita atómica e não admite consume, acquire nem acq_rel. Numa especialização aplicável, std::atomic::fetch_add é uma única operação read-modify-write e devolve o valor imediatamente anterior à soma; std::atomic::is_lock_free indica se as operações desse objeto são livres de bloqueio.

A atomicidade de uma variável não torna atómico um protocolo inteiro. Com ordens mais fracas é preciso provar a sincronização; uma mistura errada de relaxed, acquire e release pode ser logicamente incorreta mesmo sem data race.

Um atomic não é necessariamente lock-free; consulta is_lock_free(). Objetos atómicos não se copiam como valores normais. compare_exchange_weak pode falhar espuriamente, por isso costuma ser usado num ciclo e atualiza o valor esperado quando falha.

Exemplos

#include <atomic>
#include <iostream>

int main() {
    std::atomic<int> value{3};
    value.fetch_add(4);
    std::cout << value.load() << '\n';
}

Resultado

7

std::atomic → 7

Fontes