Wann würden Sie einen Mutex ohne Arc verwenden?

Question

Ein extrem häufiges Muster in Rust ist Arc<Mutex<T>>, wobei Arc bietet die Speicherverwaltung, und Mutex bietet sicheren Multithread-Zugriff auf die Ressource. Was sonst könnte anstelle von Arc verwendet werden, und unter welchen Umständen?

Answer 1

Arc ist natürlich die häufigste in diesem Zusammenhang, aber es gibt andere Zeigertypen, die Freigabe zulassen. Das wichtigste (und am häufigsten im Rest von Rust) ist die gemeinsame Referenz &T. Dies funktioniert normalerweise nicht mit std::thread::spawn 'd Threads, weil es im Allgemeinen auf Daten zeigt, die von einem anderen Thread gesteuert werden, und ist daher normalerweise nicht 'static (besonders wenn es ein &Mutex<T> ist). Sie können jedoch einen scoped thread verwenden, um einen Thread zu erstellen, der Daten mit seinem übergeordneten Element teilen kann. Z.B.

extern crate crossbeam; 
use std::sync::Mutex; 

fn main() { 
    let data = Mutex::new(vec![0, 1]); 

    crossbeam::scope(|scope| { 
     // these run concurrently: 
     let _guard = scope.spawn(|| { 
      data.lock().unwrap().push(2); 
     }); 
     data.lock().unwrap().push(3); 
    }); 

    println!("{:?}", *data.lock().unwrap()); 
    // one of [0, 1, 2, 3] or [0, 1, 3, 2] 
} 

Die Art des data in der Schließung zu scope.spawn geben wird, ist in der Tat &Mutex<Vec<i32>> (da sie nicht das move Schlüsselwort haben die Schließung des Standard-Capturing-Stil verwendet: Bezug genommen wird).

& und Arc sind die beiden, die diese Art der threadsicheren Freigabe in der Standardbibliothek/Sprache erreichen können, aber man kann auch Zeigertypen schreiben, die eine threadsichere Freigabe in externen Bibliotheken bieten.

Jedoch weg von der Pointer<Mutex<...>> Muster kann es nützlich sein, den Mutex und die Freigabe getrennt zu haben, z.B. Arc<Vec<Mutex<T>>> erlaubt es, ohne dass Arc jeder individuell eine Anzahl von Mutex<T> ‚s zu teilen, oder vielleicht will man eine Abstraktion haben um einen Mutex, und es so wickeln in einem struct:

struct Wrapped { 
    data: Mutex<T> 
} 
impl Wrapped { 
    // fancy methods that abstract over `data.lock()` 
} 

One wahrscheinlich würde dann siehe Arc<Wrapped> (oder ein anderer Zeiger, der das Teilen erlaubt).