调用接收RwLockGuard引用的Fn对象时map_guard生命周期不足问题

问题背景 #

我有一个外层RwLock包裹内部包含多个RwLock的HashMap，原本运行正常，但编写通用函数execute_with_lock（负责获取内部锁并将guard传递给业务函数）时，出现了map_guard生命周期不足的错误。想知道错误原因，以及是否可以通过指定生命周期参数解决。

相关代码 #

use std::collections::HashMap;
use std::future::Future;
use tokio::sync::{RwLock, RwLockWriteGuard};

#[derive(Debug)]
struct Data {
    pub x: u32
}

type State = RwLock<HashMap<u32, RwLock<Data>>>;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut map = HashMap::new();
    map.insert(0, RwLock::new(Data{ x: 1}));

    let state = RwLock::new(map);
    execute_with_lock(&state, do_sth1,0).await;
    Ok(())
}

async fn execute_with_lock<'a, 'b, 'c, X, F, Fut>(
    state: &'a State, f: F, key: u32
) -> Option<X>
where
    F: Fn(&'b RwLockWriteGuard<'c, Data>) -> Fut,
    Fut: Future<Output=X>,
    'a: 'c,
    'c: 'b
{
    let map_guard = state.read().await;
    if let Some(data_lock) = map_guard.get(&key) {
        let data_guard = data_lock.write().await;
        Some(f(&data_guard).await)
    } else {
        None
    }
}

async fn do_sth1<'a, 'b>(data_guard: &'a RwLockWriteGuard<'b, Data>) {
    println!("data {}", data_guard.x)
}

错误信息 #

error[E0597]: `map_guard` does not live long enough
  --> src/bin/test.rs:33:30
   |
23 | async fn execute_with_lock<'a, 'b, 'c, X, F, Fut>(
   |                                    -- 生命周期 `'c` 在此处定义
...
32 |     let map_guard = state.read().await;
   |         --------- 绑定 `map_guard` 在此处声明
33 |     if let Some(data_lock) = map_guard.get(&key) {
   |                              ^^^^^^^^^ 被借用的值生命周期不足
34 |         let data_guard = data_lock.write().await;
35 |         Some(f(&data_guard).await)
   |              -------------- 参数要求 `map_guard` 需被借用至生命周期 `'c`
...
39 | }
   | - `map_guard` 在此处被销毁，但仍处于被借用状态

问题原因 #

• map_guard是函数内的局部变量，生命周期仅覆盖函数内部的作用域，当函数执行完毕就会被销毁。
• 你在泛型约束中通过'a: 'c将'c（RwLockWriteGuard的内部生命周期）绑定到外层state的生命周期'a，但data_lock是从map_guard中获取的引用，它的生命周期实际绑定在map_guard上。编译器认为map_guard需要活到'c的结束，但map_guard的生命周期远短于'a，因此报错。

解决方案（可通过调整生命周期约束解决） #

核心是不要强行绑定内部锁的生命周期到外层state，而是使用高阶生命周期让编译器自动推导正确的依赖关系。修正后的代码如下：

use std::collections::HashMap;
use std::future::Future;
use tokio::sync::{RwLock, RwLockWriteGuard};

#[derive(Debug)]
struct Data {
    pub x: u32
}

type State = RwLock<HashMap<u32, RwLock<Data>>>;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut map = HashMap::new();
    map.insert(0, RwLock::new(Data{ x: 1}));

    let state = RwLock::new(map);
    execute_with_lock(&state, do_sth1,0).await;
    Ok(())
}

// 使用高阶生命周期，让闭包接受任意生命周期的参数
async fn execute_with_lock<'a, X, F, Fut>(
    state: &'a State, f: F, key: u32
) -> Option<X>
where
    F: for<'b, 'c> Fn(&'b RwLockWriteGuard<'c, Data>) -> Fut,
    Fut: Future<Output=X>,
{
    let map_guard = state.read().await;
    if let Some(data_lock) = map_guard.get(&key) {
        let data_guard = data_lock.write().await;
        Some(f(&data_guard).await)
    } else {
        None
    }
}

// 去掉多余的生命周期参数，让编译器自动推导
async fn do_sth1(data_guard: &RwLockWriteGuard<'_, Data>) {
    println!("data {}", data_guard.x)
}

修正说明 #

1. 高阶生命周期for<'b, 'c>：表示闭包F可以接受任意生命周期的&RwLockWriteGuard参数，编译器会根据map_guard和data_guard的实际作用域推导正确的生命周期依赖，不再强行绑定到外层state的生命周期。
2. 简化业务函数：do_sth1中无需手动指定生命周期参数，编译器会自动推导。

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