Rust中如何返回RwLockGuard内的有效MutexGuard？

你遇到的问题核心在于：MutexGuard<Baz>的有效性依赖外层RwLockGuard<Bar>的存活，但当前get_baz函数返回MutexGuard时，外层的RwLockGuard会在函数结束时被自动销毁，导致内部的MutexGuard变成无效的悬空引用。

要解决这个问题，我们需要把两个锁守卫的生命周期绑定在一起——让它们被同一个结构体持有，这样只要这个结构体还存活，两个守卫就都不会被销毁。具体实现如下：

use std::sync::{Arc, Mutex, RwLock, RwLockReadGuard};
use std::ops::{Deref, DerefMut};

struct Baz {}
impl Baz {
    async fn do_mut(&mut self) -> () {
        // 原有业务逻辑
    }
}

struct Bar {
    baz: Arc<Mutex<Baz>>
}

struct Foo {
    bar: RwLock<Bar>
}

// 自定义守卫结构体，同时持有RwLock读守卫和Mutex守卫
struct BazGuard<'a> {
    bar_guard: RwLockReadGuard<'a, Bar>,
    baz_guard: MutexGuard<'a, Baz>,
}

// 实现Deref，让BazGuard可以直接访问Baz的不可变方法
impl<'a> Deref for BazGuard<'a> {
    type Target = Baz;

    fn deref(&self) -> &Self::Target {
        &self.baz_guard
    }
}

// 实现DerefMut，支持调用Baz的可变方法
impl<'a> DerefMut for BazGuard<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.baz_guard
    }
}

impl Foo {
    async fn do_long(&mut self) -> () {
        self.bar.read().await.baz.lock().await.do_mut().await
    }

    async fn get_baz(&self) -> BazGuard<'_> {
        let bar_guard = self.bar.read().await;
        let baz_guard = bar_guard.baz.lock().await;
        BazGuard { bar_guard, baz_guard }
    }

    async fn do_short(&mut self) -> () {
        self.get_baz().await.do_mut().await
    }
}

逻辑说明 #

自定义的BazGuard结构体同时持有两个锁的守卫，两者的生命周期完全绑定在BazGuard上。只要BazGuard还在作用域内，RwLockReadGuard就不会被释放，MutexGuard也就始终保持有效。

通过实现Deref和DerefMut trait，你可以像直接操作MutexGuard<Baz>一样调用Baz的所有方法，完全不需要额外的适配代码，达到了简化重复逻辑的目的。

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