Nivel 4 · Experto· Lección 5 de 9 · 40 min
Atómicos y orden de memoria
El modelo de memoria que hay detrás de Relaxed, Acquire, Release, AcqRel y SeqCst — happens-before, compare-and-swap, y cómo elegir un orden.
Los atómicos son la base que hay debajo de cada mutex, cada canal y cada Arc. Usados directamente te dan código lock-free, y también los errores más sutiles de la programación de sistemas. Esta lección te da el modelo necesario para razonar sobre ellos en lugar de adivinar.
Tipos atómicos
std::sync::atomic proporciona AtomicBool, AtomicUsize, AtomicU64, AtomicPtr<T> y compañía. Tienen mutabilidad interior (métodos con &self) y son Sync. Cada operación es indivisible:
| Operación | Significado |
|---|---|
load, store |
leer, escribir |
swap |
escribir y devolver el valor antiguo |
fetch_add, fetch_sub, fetch_or, fetch_and, fetch_max… |
leer-modificar-escribir; devuelve el valor antiguo |
compare_exchange(current, new, success, failure) |
si el valor == current, lo pone a new; devuelve Ok(antiguo) o Err(real) |
compare_exchange_weak |
lo mismo, pero puede fallar de forma espuria; úsalo en bucles |
fetch_update(set, fetch, f) |
bucle de CAS que aplica una clausura |
use std::sync::atomic::{AtomicU64, Ordering};
use std::thread;
static HITS: AtomicU64 = AtomicU64::new(0);
fn main() {
thread::scope(|s| {
for _ in 0..8 {
s.spawn(|| {
for _ in 0..100_000 {
HITS.fetch_add(1, Ordering::Relaxed);
}
});
}
});
println!("{}", HITS.load(Ordering::Relaxed)); // siempre 800000
}
Por qué existen los órdenes
Dos capas de la máquina reordenan tu programa:
- El compilador supone una semántica de un solo hilo para la memoria normal, y reordena, fusiona y saca de los bucles lecturas y escrituras.
- La CPU tiene búferes de escritura (store buffers), ejecución fuera de orden y cachés. En ARM, POWER y RISC-V, dos hilos pueden observar de verdad las escrituras del otro en órdenes distintos. x86 es más estricto (los stores no se reordenan con otros stores), y por eso los errores se esconden allí y aparecen en un teléfono.
Rust adopta el modelo de memoria de C++20. Un orden es una declaración, tanto para el compilador como para la CPU, de qué garantías necesitas. Los órdenes más débiles permiten más optimización; los más fuertes cuestan más, sobre todo en hardware con orden débil.
Happens-before
El modelo se define en términos de un orden parcial, happens-before («ocurre antes que»):
- Dentro de un hilo, las operaciones están ordenadas por el orden del programa.
- Lanzar un hilo ocurre antes que todo lo que hay en él; todo lo que hay en un hilo ocurre antes que un
joincon éxito. - Desbloquear un mutex ocurre antes que el siguiente bloqueo.
- Un store con
Release(o más fuerte) ocurre antes que un load conAcquire(o más fuerte) que lee el valor escrito por ese store.
Una carrera de datos son dos accesos a la misma ubicación no atómica, al menos uno de ellos de escritura, sin ninguna relación happens-before entre ellos. Las carreras de datos son comportamiento indefinido. Los accesos atómicos nunca constituyen una carrera de datos, uses el orden que uses: el orden solo determina qué más queda sincronizado.
Los cinco órdenes
Relaxed: solo atomicidad. Cada variable atómica tiene un único orden total de modificación en el que todos los hilos coinciden, pero no se implica nada sobre ninguna otra memoria. Úsalo para contadores, estadísticas, generación de identificadores y banderas en las que es aceptable ver un valor atrasado.
Release (stores) y Acquire (loads): publicación. Todo lo que hizo el escritor antes del store con Release es visible para un lector después del load con Acquire que lo ve. Con esto están construidos los cerrojos, los canales, Arc y OnceLock.
AcqRel: para las operaciones de leer-modificar-escribir que a la vez observan y publican, como un CAS que toma un cerrojo.
SeqCst: todo lo que da AcqRel, más un único orden total sobre todas las operaciones SeqCst del programa, coherente con happens-before. Solo hace falta para los patrones en los que dos hilos escriben cada uno una variable y después leen la otra (store buffering); véase más abajo.
use std::cell::UnsafeCell;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
struct Slot {
ready: AtomicBool,
data: UnsafeCell<u64>,
}
// SAFETY: `data` se escribe una vez antes de activar `ready` (Release) y solo se lee
// después de observar `ready` (Acquire), así que los accesos nunca compiten.
unsafe impl Sync for Slot {}
static SLOT: Slot = Slot { ready: AtomicBool::new(false), data: UnsafeCell::new(0) };
fn main() {
thread::scope(|s| {
s.spawn(|| {
// SAFETY: ningún lector toca `data` antes de que `ready` sea true.
unsafe { *SLOT.data.get() = 42 };
SLOT.ready.store(true, Ordering::Release); // publica
});
s.spawn(|| {
while !SLOT.ready.load(Ordering::Acquire) { // se sincroniza con quien publica
std::hint::spin_loop();
}
// SAFETY: el load con Acquire vio el store con Release, así que la escritura en `data`
// ocurre antes que esta lectura.
println!("{}", unsafe { *SLOT.data.get() });
});
});
}
Cambia los dos órdenes a Relaxed y el programa tiene una carrera de datos sobre data: el lector podría ver ready == true sin que la escritura en data quede ordenada antes de su lectura. En x86 probablemente seguiría imprimiendo 42. Ese es precisamente el peligro.
La prueba de fuego del store buffering
use std::sync::atomic::{AtomicBool, Ordering::SeqCst};
use std::thread;
static X: AtomicBool = AtomicBool::new(false);
static Y: AtomicBool = AtomicBool::new(false);
fn main() {
let (a, b) = thread::scope(|s| {
let t1 = s.spawn(|| { X.store(true, SeqCst); Y.load(SeqCst) });
let t2 = s.spawn(|| { Y.store(true, SeqCst); X.load(SeqCst) });
(t1.join().unwrap(), t2.join().unwrap())
});
// Con SeqCst, al menos un hilo debe ver el store del otro.
assert!(a || b);
println!("t1 saw Y={a}, t2 saw X={b}");
}
Con SeqCst, las cuatro operaciones caen en un único orden total, así que al store que quede segundo lo precede el otro store: al menos un load devuelve true. Con Release/Acquire, los dos loads pueden devolver false: cada store puede estar esperando en el búfer de escritura de su CPU mientras el otro hilo lee el valor antiguo. Esta es la única forma habitual que de verdad necesita SeqCst (aparece en la exclusión mutua al estilo de Dekker y en algunos protocolos de despertar).
Bucles de compare-and-swap
El CAS es la pieza de construcción universal: leer, calcular y confirmar solo si nadie más cambió el valor entretanto.
use std::sync::atomic::{AtomicU32, Ordering};
use std::thread;
/// Reparte identificadores, negándose a desbordar.
fn next_id(counter: &AtomicU32) -> Option<u32> {
let mut current = counter.load(Ordering::Relaxed);
loop {
let next = current.checked_add(1)?;
match counter.compare_exchange_weak(current, next, Ordering::Relaxed, Ordering::Relaxed) {
Ok(_) => return Some(current),
Err(actual) => current = actual, // ganó otro; reintenta con el valor actualizado
}
}
}
fn main() {
let counter = AtomicU32::new(u32::MAX - 5);
let got: usize = thread::scope(|s| {
let hs: Vec<_> = (0..4)
.map(|_| s.spawn(|| (0..10).filter(|_| next_id(&counter).is_some()).count()))
.collect();
hs.into_iter().map(|h| h.join().unwrap()).sum()
});
println!("{got} IDs issued before exhaustion"); // exactamente 5
}
Los dos argumentos de orden son para el éxito y para el fallo. El orden de fallo se aplica al load que se realiza cuando la comparación falla; no puede ser más fuerte que el orden de éxito.
Caso práctico: los órdenes de Arc
Un contador de referencias muestra cómo razonar desde los primeros principios:
// La esencia del clone y el drop de Arc<T>.
fn clone(&self) -> Self {
// Relaxed: ya tenemos una referencia, así que el contador no puede llegar a cero bajo nuestros pies,
// y ningún otro acceso a memoria depende de observar este incremento.
self.inner().strong.fetch_add(1, Ordering::Relaxed);
/* … */
}
fn drop(&mut self) {
// Release: publica todos los usos que este hilo hizo de los datos…
if self.inner().strong.fetch_sub(1, Ordering::Release) != 1 {
return;
}
// …Acquire: para que el hilo que hace el decremento final los observe todos
// antes de ejecutar el destructor y liberar la memoria.
std::sync::atomic::fence(Ordering::Acquire);
unsafe { self.drop_slow() };
}
El incremento no necesita nada. El decremento debe garantizar que el hilo que libera el objeto tiene una arista happens-before desde el último uso que hizo de él cualquier otro hilo.
Orientación práctica
- Usa un
Mutexpor defecto. Bloquear sin contención cuesta un par de operaciones atómicas. Pásate a lock-free cuando lo diga un perfil. - Si tienes que elegir rápido: contadores →
Relaxed; publicar datos → store conRelease, load conAcquire; un CAS que adquiere algo →Acquireen el éxito,Relaxeden el fallo; si dudas →SeqCst, y después averigua por qué. SeqCstno es «la elección segura»: no arregla un algoritmo incorrecto, y oculta el razonamiento que necesita quien lee. Pero nunca es menos correcto que un orden más débil.- Prueba con herramientas, no con esperanza.
loomexplora exhaustivamente los entrelazados de hilos y los comportamientos de memoria débil en pruebas pequeñas. Miri simula efectos de memoria débil y detecta carreras de datos. ThreadSanitizer (-Zsanitizer=thread) encuentra carreras en ejecuciones reales. Ejecuta la integración continua en una máquina ARM. - False sharing: dos atómicos muy usados en una misma línea de caché hacen que los núcleos se peleen por ella. Sepáralos con
#[repr(align(64))]o concrossbeam_utils::CachePadded. AtomicPtr, y los atómicos en general, están sujetos al problema ABA, el tema de la próxima lección.
El tratamiento definitivo, en forma de libro, es Rust Atomics and Locks, de Mara Bos (gratis en línea). Léelo.
Ejercicios
- Implementa un spin lock con
AtomicBool: ¿qué órdenes necesitanlock(un CAS) yunlock(un store), y por qué? Añade un tipo guarda. - Implementa una inicialización perezosa al estilo de
Oncecon unAtomicU8de tres estados (sin inicializar / en curso / hecho). - Para el ejemplo de publicación, escribe la cadena happens-before desde la escritura de
datahasta su lectura. Después indica exactamente qué arista desaparece cuando el store pasa a serRelaxed. - Modela la prueba de store buffering con
loomusandoRelease/Acquirey observa cómo encuentra el resultado(false, false). - Escribe un struct contador de estadísticas con
Relaxedy varios campos, y explica por qué es imposible leer una instantánea coherente de todos los campos sin más sincronización.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué establece un store con
Releaseemparejado con un load conAcquiredel mismo atómico?2.¿Cuándo es suficiente
Ordering::Relaxed?3.¿Por qué conviene usar
compare_exchange_weaken un bucle de reintento en lugar decompare_exchange?