Perché i tipi di Rust 'Atomic * `usano funzioni non modificabili per mutare il valore?

Question

Ho notato che le strutture di Rust Atomic* dispongono di funzioni che modificano il valore, ad esempio fetch_add. Per esempio, posso scrivere questo programma:

use std::sync::atomic::{AtomicUsize, Ordering}; 

struct Tester { 
    counter: AtomicUsize 
} 

impl Tester { 
    fn run(&self) { 
     let counter = self.counter.fetch_add(1, Ordering::Relaxed); 
     println!("Hi there, this has been run {} times", counter); 
    } 
} 

fn main() { 
    let t = Tester { counter: AtomicUsize::new(0) }; 
    t.run(); 
    t.run(); 
} 

Questo compila e funziona bene, ma se cambio il AtomicUsize ad un intero normale, sarà (correttamente) non riuscire a compilare a causa delle preoccupazioni mutabilità:

struct Tester { 
    counter: u64 
} 

impl Tester { 
    fn run(&self) { 
     self.counter = self.counter + 1; 
     println!("Hi there, this has been run {} times", self.counter); 
    } 
} 

Answer 1

Non sarebbe molto utile se lo non funzionasse in questo modo. Con i riferimenti &mut, solo uno può esistere alla volta e nessun riferimento allo & in quel momento, quindi l'intera questione di atomicità dell'operazione sarebbe discutibile.

Un altro modo di vedere le cose è &mut sono unici riferimenti e &aliasable riferimenti. Per i tipi normali, la mutazione può verificarsi in modo sicuro solo se si dispone di un riferimento univoco, ma i tipi atomici riguardano esclusivamente la mutazione (tramite sostituzione) senza richiedere un riferimento univoco.

La denominazione di & e &mut è stata una questione irto, con molta paura, incertezza e dubbio nella comunità e documenti come Focusing on Ownership spiegare come stanno le cose in realtà sono. La lingua ha finito per rimanere con & e &mut, ma &mut in realtà riguarda l'unicità piuttosto che la mutabilità (è solo che la maggior parte delle volte i due sono equivalenti).