std:: atomic

Cada instanciación y especialización completa de la plantilla std::atomic define un tipo atómico. Si un hilo escribe en un objeto atómico mientras otro hilo lo lee, el comportamiento está bien definido (consulte el modelo de memoria para más detalles sobre carreras de datos).

Además, los accesos a objetos atómicos pueden establecer sincronización entre hilos y ordenar accesos a memoria no atómicos según lo especificado por std::memory_order .

std::atomic no es copiable ni movible.

Especializaciones

Plantilla principal

La plantilla principal std::atomic puede instanciarse con cualquier tipo TriviallyCopyable T que satisfaga tanto CopyConstructible como CopyAssignable . El programa está mal formado si alguno de los siguientes valores es false :

• std:: is_trivially_copyable < T > :: value
• std:: is_copy_constructible < T > :: value
• std:: is_move_constructible < T > :: value
• std:: is_copy_assignable < T > :: value
• std:: is_move_assignable < T > :: value
• std:: is_same < T, typename std:: remove_cv < T > :: type > :: value

struct Counters { int a; int b; }; // tipo definido por el usuario trivialmente copiable
std::atomic<Counters> cnt;         // especialización para el tipo definido por el usuario

std :: atomic < bool > utiliza la plantilla principal. Se garantiza que es una estructura de diseño estándar y tiene un destructor trivial .

Especializaciones parciales

La biblioteca estándar proporciona especializaciones parciales de la plantilla std::atomic para los siguientes tipos con propiedades adicionales que la plantilla principal no tiene:

Especializaciones para tipos integrales

Cuando se instancia con uno de los siguientes tipos integrales, std::atomic proporciona operaciones atómicas adicionales apropiadas para tipos integrales tales como fetch_add , fetch_sub , fetch_and , fetch_or , fetch_xor :

• Los tipos de caracteres char , char8_t (desde C++20) , char16_t , char32_t , y wchar_t ;
• Los tipos enteros con signo estándar: signed char , short , int , long , y long long ;
• Los tipos enteros sin signo estándar: unsigned char , unsigned short , unsigned int , unsigned long , y unsigned long long ;
• Cualquier tipo integral adicional requerido por los typedefs en el encabezado <cstdint> .

Además, la especialización resultante std::atomic< Integral > tiene diseño estándar , un constructor por defecto trivial, (hasta C++20) y un destructor trivial. La aritmética de enteros con signo está definida para usar complemento a dos; no hay resultados indefinidos.

Tipos de miembros

1. ↑ difference_type no está definido en la plantilla principal std::atomic ni en las especializaciones parciales para std::shared_ptr y std::weak_ptr .

Funciones miembro

Funciones miembro especializadas

Alias de tipos

Se proporcionan alias de tipo para bool y todos los tipos integrales mencionados anteriormente, de la siguiente manera:

Notas

Existen equivalentes de plantillas de funciones no miembro para todas las funciones miembro de std::atomic . Estas funciones no miembro pueden estar adicionalmente sobrecargadas para tipos que no son especializaciones de std::atomic , pero son capaces de garantizar atomicidad. El único tipo de este tipo en la biblioteca estándar es std:: shared_ptr < U > .

_Atomic es una palabra clave y se utiliza para proporcionar tipos atómicos en C.

Se recomienda que las implementaciones garanticen que la representación de _Atomic(T) en C sea la misma que la de std::atomic<T> en C++ para todo tipo posible T . Los mecanismos utilizados para garantizar atomicidad y ordenamiento de memoria deben ser compatibles.

En GCC y Clang, parte de la funcionalidad descrita aquí requiere enlazar con -latomic .

Ejemplo

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
std::atomic_int acnt;
int cnt;
void f()
{
    for (auto n{10000}; n; --n)
    {
        ++acnt;
        ++cnt;
        // Note: for this example, relaxed memory order is sufficient,
        // e.g. acnt.fetch_add(1, std::memory_order_relaxed);
    }
}
int main()
{
    {
        std::vector<std::jthread> pool;
        for (int n = 0; n < 10; ++n)
            pool.emplace_back(f);
    }
    std::cout << "The atomic counter is " << acnt << '\n'
              << "The non-atomic counter is " << cnt << '\n';
}

The atomic counter is 100000
The non-atomic counter is 69696

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también