How do I share data between several threads when I need it mutable only rarely?

Question

I have some data of type T which implements neither Copy nor Clone.

1. If I want to share my data between several threads immutably, I'll use Arc<T>.
2. If I want to share it mutably, I'll use Arc<Mutex<T>>.

What if I want to share it first mutably, and then immutably in a loop? So:

• I cannot use either Arc<T> or Arc<Mutex<Arc<T>>> because I will not be able to mutate the data in the "mutable" threads.
• I can use Arc<Mutex<T>>, but then I have to lock() it in each of the "immutable" threads to reach T, losing parallelism.
• I cannot copy data after mutation is complete, because it is expensive (or there is no way to implement Clone).

What is the right effective solution then?

Answer 1

For some use-cases (cache for example), Arc<Mutex<Arc<T>>> is an interesting solution.

The main difference with RwLock: you can get the value and use it without keeping the read lock.

fn get<T>(mutex: &Arc<Mutex<Arc<T>>>) -> Arc<T> {
    mutex.lock().unwrap().clone()
}

Full example: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2a2db2cd8aebf6a246486679f841827a

Answer 2

A std::sync::RwLock is what I am looking for, thanks @Shepmaster!