可为含锁定数据的Rust类型实现Index/IndexMut trait吗？

我定义了一个包含Mutex锁定数据的结构体LockedVector，示例代码如下：

use std::fmt::Display;
use std::ops::{Index, IndexMut};
use std::sync::Mutex;

struct LockedVector<T> {
    stuff: Mutex<Vec<T>>,
}

impl<T> LockedVector<T> {
    pub fn new(v: Vec<T>) -> Self {
        LockedVector {
            stuff: Mutex::new(v),
        }
    }
}

impl<T> Index<usize> for LockedVector<T> {
    type Output = T;
    fn index(&self, index: usize) -> &Self::Output {
        todo!()
    }
}

impl<T> IndexMut<usize> for LockedVector<T> {
    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
        let thing = self.stuff.get_mut().unwrap();
        &mut thing[index]
    }
}

impl<T: Display> Display for LockedVector<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let strings: Vec<String> = self
            .stuff
            .lock()
            .unwrap()
            .iter()
            .map(|s| format!("{}", s))
            .collect();
        write!(f, "{}", strings.join(", "))
    }
}

fn main() {
    let mut my_stuff = LockedVector::new(vec![0, 1, 2, 3, 4]);
    println!("initially: {}", my_stuff);
    my_stuff[2] = 5;
    println!("then: {}", my_stuff);
    let a_mut_var: &mut usize = &mut my_stuff[3];
    *a_mut_var = 54;
    println!("Still working: {}", my_stuff);
}

尝试为该结构体实现Index和IndexMut trait时遇到问题：当前IndexMut在可变引用场景下通过get_mut方法可正常运行，但Index trait无法实现——没有对应的get_immut方法，且无法在仅持有不可变引用时获取可变引用。

我的期望是：索引操作时自动获取锁，返回的引用在生命周期内持有锁；若使用RwLock，希望不可变索引获取读锁，可变索引获取写锁。

背景：我有一个Grid trait，有多种实现（部分线程安全），希望为其实现Index/IndexMut以使用索引语法。线程安全的Grid通常不会被持有可变引用，IndexMut主要用于初始化或非线程安全场景，而Index则适用于所有场景。

附加问题：如何优化上述Display实现代码，使其更简洁？

1. 解决索引与锁生命周期绑定的问题 #

标准Index/IndexMut trait要求返回的引用生命周期与self绑定，但Mutex/RwLock的锁守卫（MutexGuard/RwLockReadGuard）有独立的生命周期，无法直接满足该要求，因此不能直接实现标准索引trait来返回元素引用。推荐通过自定义守卫类型+索引方法来实现需求，同时保证线程安全。

基于RwLock的线程安全实现 #

改用RwLock可区分读写场景，更适合你的需求：

use std::fmt::Display;
use std::ops::{Deref, DerefMut};
use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};

struct LockedVector<T> {
    stuff: RwLock<Vec<T>>,
}

impl<T> LockedVector<T> {
    pub fn new(v: Vec<T>) -> Self {
        LockedVector {
            stuff: RwLock::new(v),
        }
    }

    // 只读索引：获取读锁，返回自定义守卫（自动持有锁至作用域结束）
    pub fn get(&self, index: usize) -> LockedVectorReadGuard<T> {
        let guard = self.stuff.read().unwrap();
        assert!(index < guard.len(), "Index out of bounds");
        LockedVectorReadGuard { guard, index }
    }

    // 可变索引：获取写锁，返回自定义守卫
    pub fn get_mut(&self, index: usize) -> LockedVectorWriteGuard<T> {
        let guard = self.stuff.write().unwrap();
        assert!(index < guard.len(), "Index out of bounds");
        LockedVectorWriteGuard { guard, index }
    }

    // 初始化场景的可变索引：直接获取内部可变引用（无需锁，仅适用于独占可变引用场景）
    pub fn index_mut_init(&mut self, index: usize) -> &mut T {
        let vec = self.stuff.get_mut().unwrap();
        &mut vec[index]
    }
}

// 只读守卫：实现Deref，模拟引用行为
struct LockedVectorReadGuard<'a, T> {
    guard: RwLockReadGuard<'a, Vec<T>>,
    index: usize,
}

impl<'a, T> Deref for LockedVectorReadGuard<'a, T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.guard[self.index]
    }
}

// 可变守卫：实现Deref和DerefMut，支持读写
struct LockedVectorWriteGuard<'a, T> {
    guard: RwLockWriteGuard<'a, Vec<T>>,
    index: usize,
}

impl<'a, T> Deref for LockedVectorWriteGuard<'a, T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.guard[self.index]
    }
}

impl<'a, T> DerefMut for LockedVectorWriteGuard<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.guard[self.index]
    }
}

使用示例 #

fn main() {
    let my_stuff = LockedVector::new(vec![0, 1, 2, 3, 4]);
    // 只读访问：自动持有读锁，离开作用域自动释放
    let elem = my_stuff.get(2);
    println!("Element at 2: {}", elem);

    // 可变访问：自动持有写锁
    let mut elem_mut = my_stuff.get_mut(3);
    *elem_mut = 54;
    println!("Updated element: {}", elem_mut);

    // 初始化场景使用独占可变引用
    let mut init_stuff = LockedVector::new(vec![0, 0, 0]);
    *init_stuff.index_mut_init(1) = 10;
    println!("Init: {}", init_stuff);
}

关于标准Index trait的说明 #

如果强行通过unsafe绕过生命周期检查实现标准Index，会导致悬垂引用（锁守卫提前释放，引用指向已解锁的内存），引发未定义行为，绝对不推荐。

2. Display实现优化 #

原实现需要先收集所有元素的字符串到Vec，存在额外内存分配。可以直接通过迭代器拼接，减少开销：

方法一：使用intersperse（Rust 1.63+） #

impl<T: Display> Display for LockedVector<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let guard = self.stuff.read().unwrap();
        guard
            .iter()
            .map(|item| write!(f, "{}", item))
            .intersperse(write!(f, ", "))
            .collect()
    }
}

方法二：手动循环（兼容低版本Rust） #

impl<T: Display> Display for LockedVector<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let guard = self.stuff.read().unwrap();
        let mut iter = guard.iter();
        if let Some(first) = iter.next() {
            write!(f, "{}", first)?;
            for item in iter {
                write!(f, ", {}", item)?;
            }
        }
        Ok(())
    }
}

两种实现都避免了额外的Vec分配，更高效简洁。

3. Grid trait适配建议 #

为了兼容线程安全与非线程安全的Grid实现，可以在trait中定义关联类型来返回索引守卫：

use std::ops::{Deref, DerefMut};

trait Grid {
    type Item;
    // 只读守卫：需实现Deref
    type ReadGuard<'a>: Deref<Target = Self::Item> where Self: 'a;
    // 可变守卫：需实现DerefMut
    type WriteGuard<'a>: DerefMut<Target = Self::Item> where Self: 'a;

    // 线程安全的只读索引
    fn get(&self, x: usize, y: usize) -> Self::ReadGuard<'_>;
    // 线程安全的可变索引
    fn get_mut(&self, x: usize, y: usize) -> Self::WriteGuard<'_>;
    // 非线程安全的初始化用可变索引
    fn index_mut_init(&mut self, x: usize, y: usize) -> &mut Self::Item;
}

线程安全实现（如基于RwLock）可返回自定义守卫类型，非线程安全实现可直接返回&T/&mut T（或用std::cell::Ref/RefMut）。

内容的提问来源于stack exchange，提问作者Edward Peters