Compartir vía

Estructura atomic

  • Artículo

Describe un objeto que realiza operaciones atomic sobre un valor almacenado del tipo Ty.

Sintaxis

template <class Ty>
struct atomic;

Miembros

Miembro Descripción
Constructor
atomic Construye un objeto atómico.
Operadores
atomic::operator Ty Lee y devuelve el valor almacenado. (atomic::load)
atomic::operator= Utiliza un valor especificado para reemplazar el valor almacenado. (atomic::store)
atomic::operator++ Incrementa el valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.
atomic::operator+= Suma un valor especificado al valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.
atomic::operator-- Disminuye el valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.
atomic::operator-= Resta un valor especificado del valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.
atomic::operator&= Realiza una operación bit a bit "and" (&) sobre un valor especificado y el valor almacenado. Solo lo utilizan las especializaciones de entero.
atomic::operator|= Realiza una operación bit a bit "or" (|) sobre un valor especificado y el valor almacenado. Solo lo utilizan las especializaciones de entero.
atomic::operator^= Realiza una operación bit a bit "exclusive or" (^) sobre un valor especificado y el valor almacenado. Solo lo utilizan las especializaciones de entero.
Funciones
compare_exchange_strong Realiza una operación atomic_compare_and_exchange sobre this y devuelve el resultado.
compare_exchange_weak Realiza una operación weak_atomic_compare_and_exchange sobre this y devuelve el resultado.
fetch_add Suma un valor especificado al valor almacenado.
fetch_and Realiza una operación bit a bit "and" (&) sobre un valor especificado y el valor almacenado.
fetch_or Realiza una operación bit a bit "or" (|) sobre un valor especificado y el valor almacenado.
fetch_sub Resta un valor especificado del valor almacenado.
fetch_xor Realiza una operación bit a bit "exclusive or" (^) sobre un valor especificado y el valor almacenado.
is_lock_free Especifica si las operaciones atomic en this no tienen bloqueos. Un tipo atomic no tiene bloqueos si ninguna operación atomic sobre ese tipo emplea bloqueos.
load Lee y devuelve el valor almacenado.
store Utiliza un valor especificado para reemplazar el valor almacenado.

Comentarios

El tipo Ty se debe poder copiar de forma trivial. Es decir, el uso de memcpy para copiar sus bytes debe generar un objeto Ty válido que sea igual que el objeto original. Las funciones miembro compare_exchange_weak y compare_exchange_strong usan memcmp para determinar si dos valores Ty son iguales. Estas funciones no utilizarán un Ty definido por operator==. Las funciones miembro de atomic utilizan memcpy para copiar valores de tipo Ty.

Existe una especialización parcial, atomic<Ty*>, para todos los tipos de puntero. La especialización permite sumar un desplazamiento al valor del puntero administrado o restar un desplazamiento del mismo. Las operaciones aritméticas toman un argumento de tipo ptrdiff_t y ajustan ese argumento según el tamaño de Ty para que sea coherente con la aritmética normal de dirección.

Existe una especialización para cada tipo entero excepto bool. Cada especialización proporciona un conjunto completo de métodos para operaciones aritméticas y lógicas atómicas.

atomic<char>
atomic<signed char>
atomic<unsigned char>
atomic<char16_t>
atomic<char32_t>
atomic<wchar_t>
atomic<short>

atomic<unsigned short>
atomic<int>
atomic<unsigned int>
atomic<long>
atomic<unsigned long>
atomic<long long>
atomic<unsigned long long>

Las especializaciones de entero se derivan de los tipos atomic_integral correspondientes. Por ejemplo, atomic<unsigned int> se deriva de atomic_uint.

Requisitos

Encabezado: <atomic>

Espacio de nombres: std

atomic::atomic

Construye un objeto atómico.

atomic();
atomic( const atomic& );
atomic( Ty Value ) noexcept;

Parámetros

Value
Valor de inicialización.

Comentarios

Los objetos atómicos no se pueden copiar o mover.

Los objetos que son creaciones de instancias de atomic<Ty> solo los puede inicializar el constructor que toma un argumento de tipo Ty y no mediante la inicialización de agregado. Sin embargo, los objetos atomic_integral solo se pueden inicializar mediante la inicialización de agregado.

atomic<int> ai0 = ATOMIC_VAR_INIT(0);
atomic<int> ai1(0);

atomic::operator Ty

Operador del tipo especificado en la plantilla, atomic<Ty>. Recupera el valor almacenado en *this.

atomic<Ty>::operator Ty() const volatile noexcept;
atomic<Ty>::operator Ty() const noexcept;

Comentarios

Este operador aplica el memory_order_seq_cst memory_order.

atomic::operator=

Almacena un valor especificado.

Ty operator=(
   Ty Value
) volatile noexcept;
Ty operator=(
   Ty Value
) noexcept;

Parámetros

Value
Un objeto Ty.

Valor devuelto

Devuelve Value.

atomic::operator++

Incrementa el valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.

Ty atomic<Ty>::operator++(int) volatile noexcept;
Ty atomic<Ty>::operator++(int) noexcept;
Ty atomic<Ty>::operator++() volatile noexcept;
Ty atomic<Ty>::operator++() noexcept;

Valor devuelto

Los dos primeros operadores devuelven el valor incrementado; los dos últimos operadores devuelven el valor antes del incremento. Los operadores usan .memory_order_seq_cst memory_order

atomic::operator+=

Suma un valor especificado al valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.

Ty atomic<Ty>::operator+=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator+=(
   Ty Value
) noexcept;

Parámetros

Value
Valor integral o de puntero.

Valor devuelto

Objeto Ty que contiene el resultado de la suma.

Comentarios

Este operador usa .memory_order_seq_cst memory_order

atomic::operator--

Disminuye el valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.

Ty atomic<Ty>::operator--(int) volatile noexcept;
Ty atomic<Ty>::operator--(int) noexcept;
Ty atomic<Ty>::operator--() volatile noexcept;
Ty atomic<Ty>::operator--() noexcept;

Valor devuelto

Los dos primeros operadores devuelven el valor reducido; los dos últimos operadores devuelven el valor antes de la reducción. Los operadores usan .memory_order_seq_cst memory_order

atomic::operator-=

Resta un valor especificado del valor almacenado. Solo lo utilizan las especializaciones de entero y de puntero.

Ty atomic<Ty>::operator-=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator-=(
   Ty Value
) noexcept;

Parámetros

Value
Valor integral o de puntero.

Valor devuelto

Objeto Ty que contiene el resultado de la resta.

Comentarios

Este operador usa .memory_order_seq_cst memory_order

atomic::operator&=

Realiza una operación bit a bit "and" (&) sobre un valor especificado y el valor almacenado de *this. Solo lo utilizan las especializaciones de entero.

atomic<Ty>::operator&= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator&= (
   Ty Value
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Valor devuelto

El resultado de "and" bit a bit (&).

Comentarios

Este operador realiza una operación de lectura-modificación-escritura para reemplazar el valor almacenado de *this por un valor "and" bit a bit (&) de Value y el valor actual almacenado en *this, dentro de las restricciones de memory_order_seq_cst memory_order.

atomic::operator|=

Realiza una operación bit a bit "or" (|) sobre un valor especificado y el valor almacenado de *this. Solo lo utilizan las especializaciones de entero.

atomic<Ty>::operator|= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator|= (
   Ty Value
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Valor devuelto

Resultado de la operación bit a bit "or" (|).

Comentarios

Este operador realiza una operación de lectura-modificación-escritura para reemplazar el valor almacenado de *this por un valor bit a bit "o" (|) de Value y el valor actual almacenado en *this, dentro de las restricciones de las memory_order_seq_cst memory_order restricciones.

atomic::operator^=

Realiza una operación bit a bit "exclusive or" (^) sobre un valor especificado y el valor almacenado de *this. Solo lo utilizan las especializaciones de entero.

atomic<Ty>::operator^= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator^= (
   Ty Value
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Valor devuelto

Resultado de la operación bit a bit "exclusive or" (^).

Comentarios

Este operador realiza una operación de lectura-modificación-escritura para reemplazar el valor almacenado de *this por un valor "exclusivo" bit a bit (^) de Value y el valor actual almacenado en *this, dentro de las restricciones de las memory_order_seq_cst memory_order restricciones.

atomic::compare_exchange_strong

Realiza una operación atómica de comparación e intercambio sobre *this.

bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

Parámetros

Exp
Valor de tipo Ty.

Value
Valor de tipo Ty.

Order1
Primer argumento memory_order.

Order2
Segundo argumento memory_order.

Valor devuelto

Número bool que indica el resultado de la comparación de valores.

Comentarios

Esta operación atómica de comparación e intercambio compara el valor almacenado en *this con Exp. Si los valores son iguales, la operación reemplaza el valor almacenado en *this con Value mediante una operación de lectura-modificación-escritura y aplicando las restricciones de ordenación de memoria especificadas por Order1. Si los valores no son iguales, la operación utiliza el valor almacenado en *this para reemplazar Exp y aplica las restricciones de ordenación de memoria especificadas por Order2.

Las sobrecargas que no tienen un segundo memory_order usan un Order2 implícito basado en el valor de Order1. Si Order1 es memory_order_acq_rel, Order2 es memory_order_acquire. Si Order1 es memory_order_release, Order2 es memory_order_relaxed. En todos los demás casos, Order2 es igual que Order1.

Para las sobrecargas que toman dos parámetros memory_order, el valor de Order2 no debe ser memory_order_release o memory_order_acq_rel, y no debe ser más seguro que el valor de Order1.

atomic::compare_exchange_weak

Realiza una operación atómica débil de comparación e intercambio sobre *this.

bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

Parámetros

Exp
Valor de tipo Ty.

Value
Valor de tipo Ty.

Order1
Primer argumento memory_order.

Order2
Segundo argumento memory_order.

Valor devuelto

Número bool que indica el resultado de la comparación de valores.

Comentarios

Esta operación atómica de comparación e intercambio compara el valor almacenado en *this con Exp. Si los valores son iguales, la operación reemplaza el valor almacenado en *this con Value mediante una operación de lectura-modificación-escritura y aplicando las restricciones de ordenación de memoria especificadas por Order1. Si los valores no son iguales, la operación utiliza el valor almacenado en *this para reemplazar Exp y aplica las restricciones de ordenación de memoria especificadas por Order2.

Una operación atómica débil de comparación e intercambio realiza un intercambio si los valores comparados son iguales. Si los valores no son iguales, no se garantiza que la operación realice un intercambio.

Las sobrecargas que no tienen un segundo memory_order usan un Order2 implícito basado en el valor de Order1. Si Order1 es memory_order_acq_rel, Order2 es memory_order_acquire. Si Order1 es memory_order_release, Order2 es memory_order_relaxed. En todos los demás casos, Order2 es igual que Order1.

Para las sobrecargas que toman dos parámetros memory_order, el valor de Order2 no debe ser memory_order_release o memory_order_acq_rel, y no debe ser más seguro que el valor de Order1.

atomic::exchange

Utiliza un valor especificado para reemplazar el valor almacenado de *this.

Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Order
Un objeto memory_order.

Valor devuelto

Valor almacenado de *this antes del intercambio.

Comentarios

Esta operación realiza una operación de lectura-modificación-escritura para utilizar Value para reemplazar el valor almacenado en *this, dentro de las restricciones de memoria especificadas por Order.

atomic::fetch_add

Captura el valor almacenado en *this y, a continuación, agrega un valor especificado al valor almacenado.

Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Order
Un objeto memory_order.

Valor devuelto

Objeto Ty que contiene el valor almacenado en *this antes de la adición.

Comentarios

El método fetch_add realiza una operación de lectura-modificación-escritura para sumar Value de forma atómica al valor almacenado en *this, y aplica las restricciones de memoria especificadas por Order.

atomic::fetch_and

Realiza una operación "and" bit a bit (&) sobre un valor y un valor existente que está almacenado en *this.

Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Order
Un objeto memory_order.

Valor devuelto

Objeto Ty que contiene el resultado de la operación "and" bit a bit (&).

Comentarios

El método fetch_and realiza una operación de lectura-modificación-escritura para reemplazar el valor almacenado de *this con una operación "and" bit a bit (&) de Value y el valor actual almacenado en *this, dentro de las restricciones de memoria especificadas por Order.

atomic::fetch_or

Realiza una operación "or" bit a bit (|) sobre un valor y un valor existente que está almacenado en *this.

Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Order
Un objeto memory_order.

Valor devuelto

Objeto Ty que contiene el resultado de la operación "or" bit a bit (|).

Comentarios

El método fetch_or realiza una operación de lectura-modificación-escritura para reemplazar el valor almacenado de *this con una operación "or" bit a bit (|) de Value y el valor actual almacenado en *this, dentro de las restricciones de memoria especificadas por Order.

atomic::fetch_sub

Resta un valor especificado del valor almacenado.

Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Order
Un objeto memory_order.

Valor devuelto

Objeto Ty que contiene el resultado de la resta.

Comentarios

El método fetch_sub realiza una operación de lectura-modificación-escritura para restar Value de forma atómica del valor almacenado en *this, dentro de las restricciones de memoria especificadas por Order.

atomic::fetch_xor

Realiza una operación "exclusive or" bit a bit (^) sobre un valor y un valor existente que está almacenado en *this.

Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Valor de tipo Ty.

Order
Un objeto memory_order.

Valor devuelto

Objeto Ty que contiene el resultado de la operación "exclusive or" bit a bit (^).

Comentarios

El método fetch_xor realiza una operación de lectura-modificación-escritura para reemplazar el valor almacenado de *this con una operación "exclusive or" bit a bit (^) de Value y el valor actual almacenado en *this, y aplica las restricciones de memoria especificadas por Order.

atomic::is_lock_free

Especifica si las operaciones atomic en *this no tienen bloqueos.

bool is_lock_free() const volatile noexcept;

Valor devuelto

true si las operaciones atomic en *this no tienen bloqueos; de lo contrario, false.

Comentarios

Un tipo atomic no tiene bloqueos si ninguna operación atomic sobre ese tipo emplea bloqueos.

atomic::load

Recupera el valor almacenado en *this, dentro de las restricciones de memoria especificadas.

Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const volatile noexcept;
Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const noexcept;

Parámetros

Order
memory_order. Order no debe ser memory_order_release o memory_order_acq_rel.

Valor devuelto

Valor recuperado que se almacena en *this.

atomic::store

Almacena un valor especificado.

void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parámetros

Value
Un objeto Ty.

Order
Una restricción memory_order.

Comentarios

Este método almacena de forma atómica Value en *this, dentro de las restricciones de memoria especificadas por Order.

Consulte también

<atomic>
Referencia de archivos de encabezado