std::atomic_is_lock_free, ATOMIC_xxx_LOCK_FREE

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de operaciones atómicas

Tipos

atomic (C++11)

atomic_ref (C++20)

Funciones

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

atomic_waitatomic_wait_explicit (C++20)(C++20)

atomic_notify_one (C++20)

atomic_notify_all (C++20)

Banderas atómicas

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_flag_testatomic_flag_test_explicit (C++20)(C++20)

atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20)

atomic_flag_notify_one (C++20)

atomic_flag_notify_all (C++20)

Inicialización

atomic_init (C++11)(en desuso en C++20)

ATOMIC_VAR_INIT (C++11)(en desuso en C++20)

ATOMIC_FLAG_INIT (C++11)(en desuso en C++20)

Ordenamiento de memoria

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num t-dcl-rev-notes t-since-cxx11 "> </tbody><tbody> </tbody>

Definido en el archivo de encabezado <atomic>
	(1)	(desde C++11)
template< class T > bool atomic_is_lock_free( const volatile std::atomic<T>* obj ) noexcept;
template< class T > bool atomic_is_lock_free( const std::atomic<T>* obj ) noexcept;
#define ATOMIC_BOOL_LOCK_FREE /* sin especificar */ #define ATOMIC_CHAR_LOCK_FREE /* sin especificar */ #define ATOMIC_CHAR16_T_LOCK_FREE /* sin especificar */ #define ATOMIC_CHAR32_T_LOCK_FREE /* sin especificar */ #define ATOMIC_WCHAR_T_LOCK_FREE /* sin especificar */ #define ATOMIC_SHORT_LOCK_FREE /* sin especificar */ #define ATOMIC_INT_LOCK_FREE /* sin especificar */ #define ATOMIC_LONG_LOCK_FREE /* sin especificar */ #define ATOMIC_LLONG_LOCK_FREE /* sin especificar */ #define ATOMIC_POINTER_LOCK_FREE /* sin especificar */			(2)	(desde C++11)
#define ATOMIC_CHAR8_T_LOCK_FREE /* sin especificar */			(3)	(desde C++20)

1) Determina si el objeto atómico al que apunta obj se implementa libre de bloqueo, como si lo fuera llamando a obj->is_lock_free(). En la ejecución de cualquier programa, el resultado de la consulta sin bloqueo es la misma para todos los objetos atómicos del mismo tipo..

2,3) Se expande a una expresión constante entera con valor:

• 0 para los tipos atómicos integrados que nunca son libres de bloqueo;
• 1 para los tipos atómicos integrados que a veces son libres de bloqueo;
• 2 para los tipos atómicos integrados que siempre son libres de bloqueo.

Parámetros

obj

-

Puntero al objeto atómico a examinar.

Valor de retorno

true si *obj es atómico libre de bloqueo, false de lo contrario.

Notas

Todos los tipos atómicos excepto std::atomic_flag implementarse usando mutex u otras operaciones de bloqueo, en lugar de usar las instrucciones atómicas sin bloqueo de CPU. Los tipos atómicos también pueden ser a veces libres de bloqueo: por ejemplo, si solo algunas subarquitecturas admiten el acceso atómico sin bloqueo para un tipo determinado (como la instrucción CMPXCHG16B en x86-64), puede no conocerse hasta el tiempo de ejecución si los tipos atómicos son libres de bloqueo.

El estándar de C++ recomienda (pero no requiere) que las operaciones atómicas sin bloqueo también sean libres de direcciones, es decir, adecuadas para la comunicación entre procesos que utilizan memoria compartida.

Ejemplo

Ejecuta este código

#include <iostream>
#include <utility>
#include <atomic>

struct A { int a[100]; };
struct B { int x, y; };
int main()
{
    std::atomic<A> a;
    std::atomic<B> b;
    std::cout << std::boolalpha
              << "std::atomic<A> es libre de bloqueo? "
              << std::atomic_is_lock_free(&a) << '\n'
              << "std::atomic<B> es libre de bloqueo? "
              << std::atomic_is_lock_free(&b) << '\n';
}

Posible salida:

std::atomic<A> es libre de bloqueo? false
std::atomic<B> es libre de bloqueo? true

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 3249	C++11	atomic_is_lock_free se especificaba mediante punteros, lo que era ambiguo y podría aceptar valores de puntero inválidos.	Especificado mediante objetos atómicos.

Véase también

is_lock_free	Comprueba si el objeto atómico es sin bloqueo. (función miembro pública de std::atomic)
std::atomic_is_lock_free(std::shared_ptr)	Especializa las operaciones atómicas para std::shared_ptr. (plantilla de función)
atomic_flag (C++11)	El tipo atómico booleano libre de bloqueo. (clase)
is_always_lock_free [estático] (C++17)	Indica que el tipo es siempre libre de bloqueo. (constante miembro pública estática de std::atomic)
Documentación de C para atomic_is_lock_free
Documentación de C para ATOMIC_*_LOCK_FREE