Atómicos en Rust

Para un contador o una bandera, un atómico sale más barato que un mutex.

use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

fn main() {
    let hits = Arc::new(AtomicUsize::new(0));
    let done = Arc::new(AtomicBool::new(false));

    let handles: Vec<_> = (0..4)
        .map(|_| {
            let hits = Arc::clone(&hits);
            thread::spawn(move || {
                for _ in 0..500 {
                    hits.fetch_add(1, Ordering::Relaxed);
                }
            })
        })
        .collect();

    for h in handles {
        h.join().unwrap();
    }
    done.store(true, Ordering::Release);

    println!("{}", hits.load(Ordering::Acquire));
    println!("{}", done.load(Ordering::Acquire));
}

Cómo funciona

1. fetch_add incrementa y devuelve el valor anterior.
2. Ordering declara qué tan estrictas son las garantías de memoria.
3. Sin lock, sin guard, sin riesgo de envenenamiento.

Palabras clave y builtins usados aquí

• Vec
• fn
• for
• in
• let
• move
• use

El intento, en números

Líneas

27

Caracteres a escribir

540

Tokens

190

Ritmo de tres estrellas

105 tpm

Al ritmo de tres estrellas de 105 tokens por minuto, este intento toma unos 109 segundos.

Escribe este fragmento

Paso 3 de 3 en Estado compartido; paso 6 de 15 en Concurrencia y async.

← Anterior Siguiente →