Thread-sicherer gemeinsamer Zustand mit Arc<Mutex<T>>

Snippet

Thread-sicherer gemeinsamer Zustand mit Arc<Mutex<T>>

Arc<T> (Atomare Referenzzählung) ermöglicht mehrere Eigentümer über Threads hinweg. Mutex<T> bietet gegenseitigen Ausschluss, um Datenrennen zu verhindern, wenn mehrere Threads dieselben Daten mutieren müssen. Die lock()-Methode blockiert, bis die Sperre erworben wird, und gibt einen MutexGuard<T> zurück, der beim Drop automatisch freigegeben wird. Diese Kombination ist Rusts Hauptmechanismus für sicheren gemeinsamen veränderlichen Zustand in nebenläufigen Programmen.

snippet.rs
rust
use std::sync::{Arc, Mutex};
use std::thread;
 
fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
 
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
 
    println!("Result: {}", *counter.lock().unwrap());
}

Erklärung

Arc::new(Mutex::new(0))

Erstellt gemeinsames Eigentum mit atomarer Referenzzählung und gegenseitigem Ausschluss

Arc::clone(&counter)

Klonen für jeden Thread - günstige Referenzzählungsinkrementierung, keine tiefe Kopie

let mut num = counter.lock().unwrap();

Sperre erwerben; unwrap paniced bei Vergiftung; num ist MutexGuard<i32>

*num += 1;

Ändern durch den Wächter; Sperre automatisch freigegeben wenn num den Scope verlässt

Vorheriges Snippet Nächstes Snippet

Verwandt

Aus deiner Bibliothek