std::atomic y órdenes de memoria
Use std::atomic con el orden de memoria adecuado para garantizar corrección y velocidad.
std::atomic y órdenes de memoria es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
Más allá de los mutexes
Los locks serializan el acceso: son sencillos y correctos, pero limitan el rendimiento. std::atomic proporciona componentes básicos sin locks para código concurrente de alto rendimiento.
Fundamentos de std::atomic
Un std::atomic<T> encapsula un valor y admite operaciones atómicas de lectura, modificación y escritura.
#include <atomic>
std::atomic<int> counter{0};
counter.fetch_add(1); // atomic increment
int v = counter.load();
counter.store(0);Operadores de conveniencia
Para los tipos aritméticos, los operadores habituales son atómicos.
std::atomic<int> n{0};
++n; // atomic increment
n += 5; // atomic add
int v = n; // atomic loadPor qué los atómicos son difíciles
La CPU puede reordenar las operaciones de memoria entre distintos núcleos. El orden de memoria especifica qué reordenaciones están permitidas.
Órdenes de memoria
Cinco órdenes habituales:
memory_order_relaxed— atómico, pero sin ordenaciónmemory_order_acquire— se combina con release; no permite reordenar despuésmemory_order_release— se combina con acquire; no permite reordenar antesmemory_order_acq_rel— ambas propiedadesmemory_order_seq_cst— coherencia secuencial (predeterminado)
Coherencia secuencial: valor predeterminado seguro
El valor predeterminado seq_cst se comporta de forma intuitiva: todos los atómicos parecen ejecutarse en un único orden global. Es más lento que los órdenes relaxed, pero resulta más fácil de razonar.
Emparejamiento acquire-release
Utilice release en el productor y acquire en el consumidor. Después de acquire, todas las escrituras realizadas antes del release correspondiente son visibles.
std::atomic<bool> ready{false};
int data = 0;
// producer
data = 42;
ready.store(true, std::memory_order_release);
// consumer
while (!ready.load(std::memory_order_acquire));
std::cout << data; // sees 42Orden relaxed
Los atómicos relaxed garantizan la atomicidad, evitando lecturas fragmentadas, pero permiten cualquier reordenación. Utilícelos para contadores simples cuando el orden no importe.
Comparación e intercambio
Es la base de la mayoría de los algoritmos sin locks. compare_exchange_strong(expected, desired) actualiza el valor atómicamente solo si el valor actual es igual a expected.
std::atomic<int> a{10};
int expected = 10;
bool ok = a.compare_exchange_strong(expected, 20);
// if true, a is now 20; otherwise expected holds the actual current valueCAS débil frente a CAS fuerte
compare_exchange_weak puede fallar espuriamente incluso cuando los valores coinciden. Utilícelo dentro de bucles, ya que es más barato en algunas plataformas; utilice strong fuera de los bucles.
Lock-free frente a wait-free
Dos garantías de progreso:
- Lock-free — al menos un hilo progresa en todo momento
- Wait-free — todos los hilos progresan en un tiempo acotado
Cuándo usar atómicos
Los atómicos no siempre son más rápidos que los mutexes. Utilícelos cuando pueda mantener sencilla la ruta crítica: para contadores, indicadores y estados simples. Para estados compartidos complejos, los mutexes suelen ser más seguros y claros.
Comprobación rápida
¿Qué orden de memoria ofrece las garantías más sólidas, pero también es el más lento?
Resumen
std::atomic proporciona primitivas sin locks con ordenación de memoria explícita. Utilice de forma predeterminada memory_order_seq_cst; use pares acquire/release para patrones productor-consumidor y relaxed solo para operaciones atómicas sin ordenación, como los contadores.
Preguntas frecuentes
¿La lección «std::atomic y órdenes de memoria» es gratis?
Sí — el texto completo de «std::atomic y órdenes de memoria» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «std::atomic y órdenes de memoria»?
Use std::atomic con el orden de memoria adecuado para garantizar corrección y velocidad. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «std::atomic y órdenes de memoria»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- std::atomic y órdenes de memoria
- Patrones de comparación e intercambio (CAS)
- Implementación de una cola sin bloqueos
- Punteros de peligro y el problema ABA