如何设计一个可变的Mutex集合？

Question

我需要一个可变的 Mutex 集合，需要在多个线程之间共享。这个集合的目的是为了根据给定的键返回 MutexGuard 列表（以便能够根据键值同步线程）。请注意，当初始化时，此集合中没有 Mutex，这些需要根据键值在运行时创建。

我的代码如下：

use std::collections::HashMap;
use std::sync::{Arc, Mutex, MutexGuard};

struct Bucket {
    locks: HashMap<String, Mutex<()>>,
}

impl Bucket {
    // This method will create and add one or multiple Mutex to the 
    // collection (therefore it needs to take self as mutable), according 
    // to the give key (if the Mutex already exist it will just return
    // its MutexGuard).
    fn get_guards(
        &mut self,
        key: impl Into<String>,
    ) -> Vec<MutexGuard<'_, ()>> {
        let lock = self.locks.entry(key.into()).or_default();
        vec![lock.lock().unwrap()]
    }
}

impl Default for Bucket {
    fn default() -> Self {
        Self {
            locks: HashMap::new(),
        }
    }
}

fn main() {
    // I need to wrap the bucket in a Arc<Mutex> since it's going to be shared
    // between multiple threads
    let mut bucket = Arc::new(Mutex::new(Bucket::default()));

    // Here I need to get a list of guards, so that until they are dropped
    // I can synchronize multiple threads with the same key (or to be more
    // precise with the same MutexGuards, as different keys may yields the
    // same MutexGuards).
    let guards = {
        // IMPORTANT: I need to unlock the Mutex used for the `bucket` (with
        // write access) asap, otherwise it will nullify the purpose of the
        // bucket, since the write lock would be hold for the whole `guards`
        // scope.
        let mut b = bucket.lock().unwrap();
        b.get_guards("key")
    };
}

播放示例链接

我遇到的错误信息如下：

error[E0597]: `b` does not live long enough
  --> src/main.rs:29:9
   |
27 |     let _guards = {
   |         ------- borrow later stored here
28 |         let mut b = bucket.lock().unwrap();
29 |         b.get_guards("key")
   |         ^ borrowed value does not live long enough
30 |     };
   |     - `b` dropped here while still borrowed

error: aborting due to previous error

有没有一种方法可以设计我的Bucket集合的Mutex，以便我能够实现我的目标？

- Nick

Answer 1

基本上，您想从一个被锁定的对象中借用一个对象，并在其封闭对象解锁后保留它。

在这种情况下，非静态借用是不可能的，因为这是不安全的，例如，任何其他线程都可能放弃您先前借用的对象的所有者。

根据您的逻辑，内部锁需要在其他线程之间安全共享，您需要使用Arc包装您的互斥锁。

struct Bucket {
    locks: HashMap<String, Arc<Mutex<()>>>,
}

这将返回内部互斥锁的原子引用。

//previously get_guards
fn get_mutexes(&mut self, key: impl Into<String>) -> Vec<Arc<Mutex<()>>> {
    let lock = self.locks.entry(key.into()).or_default();
    vec![lock.clone()]
}

你可以像这样简单地锁定所有需要的互斥锁：

let mutexes = bucket.lock().unwrap().get_mutexes("key"); // locks(borrows bucket's guard) temporarily in here
let guards: Vec<MutexGuard<'_, ()>> =
    mutexes.iter().map(|guard| guard.lock().unwrap()).collect();

请查看完整代码Playground。

- Ömer Erden