data-structures - 如何锁定 Rust 数据结构的内部结构？

Question

我正在尝试实现一个将值存储在向量和 HashMap 中的集合，这是我目前所拥有的:

pub struct CollectionWrapper {
    items:      Vec<Item>,
    items_map:  HashMap<ItemKey, Item>,
}

impl CollectionWrapper {
    pub fn new() -> Self {
        CollectionWrapper {
            items: Vec::new(),
            items_map: HashMap::new(),
        }
    }

    pub fn add(&mut self, item: Item) {
        let key = item.get_key();
        self.items.push(item.clone());
        self.items_map.insert(key, item.clone());
    }
}

我显然需要某种锁。我看过 Mutex Rust 有，但我不明白如何使用它。当我搜索问题时，我只找到人们生成一堆线程并同步它们的用例。我正在寻找类似的东西:

try {
    lock.lock();
    // insert into both collections
} finally {
    lock.unlock();
}

Answer 1

I obviously need some kind of lock

我不知道我同意这个需求。当多个线程可以同时修改对象时，我只会引入锁。请注意，这是两个条件:多线程和并发修改。

如果您只有一个线程，那么 Rust 对项目的单个可变引用的强制执行将防止任何问题。同样，如果您有多个线程并在它们之间完全转移项目的所有权，则不需要任何锁定，因为只有一个线程可以改变它。

I'm looking for something like:

try {
    lock.lock();
    // insert into both collections
} finally {
    lock.unlock();
}

如果您需要类似的东西，那么您可以创建一个 Mutex<()> — 锁定单元类型的互斥量，不占用空间:

use std::sync::Mutex;

struct Thing {
    lock: Mutex<()>,
    nums: Vec<i32>,
    names: Vec<String>,
}

impl Thing {
    fn new() -> Thing {
        Thing {
            lock: Mutex::new(()),
            nums: vec![],
            names: vec![],
        }
    }

    fn add(&mut self) {
        let _lock = self.lock.lock().unwrap();
        // Lock is held until the end of the block

        self.nums.push(42);
        self.names.push("The answer".to_string());
    }
}

fn main() {
    let mut thing = Thing::new();
    thing.add();
}

请注意，没有明确的 unlock必需的。当您调用 lock ，你会得到一个 MutexGuard .这种类型实现了 Drop ，它允许代码在超出范围时运行。在这种情况下，锁会自动释放。这通常称为资源获取即初始化 (RAII)。

在大多数情况下，我不推荐这种做法。通常最好将要锁定的元素包裹起来。这强制对项目的访问可以仅在锁定时发生:

use std::sync::Mutex;

struct Thing {
    nums: Vec<i32>,
    names: Vec<String>,
}

impl Thing {
    fn new() -> Thing {
        Thing {
            nums: vec![],
            names: vec![],
        }
    }

    fn add(&mut self) {
        self.nums.push(42);
        self.names.push("The answer".to_string());
    }
}

fn main() {
    let thing = Thing::new();
    let protected = Mutex::new(thing);
    let mut locked_thing = protected.lock().unwrap();
    locked_thing.add();
}

请注意 MutexGuard还实现了 Deref 和 DerefMut ，这让它“看起来”像锁定类型。