Warum verwenden die `Atomic *` -Typen von Rust nicht veränderbare Funktionen, um den Wert zu mutieren?

Question

Ich bemerke, dass Rust Atomic* Strukturen Funktionen haben, die den Wert ändern, wie fetch_add. Zum Beispiel kann ich dieses Programm schreiben:

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(); 
} 

Dies kompiliert und läuft gut, aber wenn ich die AtomicUsize auf eine normale ganze Zahl ändern, wird es (richtig) scheitern an Veränderlichkeit Bedenken zu kompilieren:

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

Es wäre nicht sehr nützlich, wenn es nicht auf diese Weise funktioniert. Mit &mut Referenzen, nur eins kann zu einer Zeit existieren, und keine & Referenzen zu dieser Zeit, so dass die ganze Frage der Atomizität der Operation strittig wäre.

Ein anderer Weg, es zu betrachten ist &muteinzigartige Referenzen sind, und &aliasable Referenzen. Bei normalen Typen kann Mutation nur dann sicher auftreten, wenn Sie eine eindeutige Referenz haben, bei atomaren Typen geht es jedoch nur um Mutation (über Ersatz), ohne dass eine eindeutige Referenz benötigt wird.

Die Nennung von & und &mut hat in der Gemeinde und Dokumente wie Focusing on Ownership zu erklären, wie die Dinge sind eigentlich eine volle Materie, mit vieler Angst, Unsicherheit und Zweifeln gewesen. Die Sprache ist bei & und &mut gelandet, aber &mut ist eigentlich über Einzigartigkeit eher als Veränderlichkeit (es ist gerade, dass die meiste Zeit die zwei äquivalent sind).