Rust中等待同一Future要求'static生命周期的问题如何解决

问题1：实现思路是否常规 #

• 这个避免重复请求的思路是完全常规的业内通用解法，一般称为「请求合并/共享」模式，针对OAuth token这类有有效期、需要跨请求共享、请求成本高的资源，通过缓存正在进行的请求Future，让后续并发的同需求请求共享同一个请求结果，既避免重复发起请求浪费资源，也不会触发服务端的频次限制，逻辑非常合理。

问题2：错误原因及修正方案 #

错误原因 #

你遇到的生命周期错误是两个问题叠加导致的：

1. Rust中dyn Trait默认携带'static生命周期约束，你定义的dyn Future<Output = Result<String, ()>> + Send没有标注生命周期，编译器默认要求它满足'static要求。
2. 你的get_access_token_from_server方法接收&mut self参数，它返回的Future捕获了self的可变引用，而self的生命周期显然不是'static，和上述默认约束冲突。同时你把捕获了self引用的Future存在self的requesting字段里，还会形成自引用结构，这是Rust编译期不允许的用法。

修正思路 #

核心是避免请求Future持有Token结构体的引用，从根源上消灭生命周期冲突：

• 将请求token的逻辑和更新结构体字段的逻辑拆分，请求Future只负责调用接口返回token结果，不持有Token的任何引用。
• 拿到请求结果后再更新Token的token字段，同时请求完成后清空requesting字段的缓存，方便下次过期后发起新请求。
• 持有Mutex锁期间只做状态判断、缓存读写操作，不要在持有锁的状态下await Future，否则会导致锁长期被占用，其他请求无法进入，失去共享请求的意义。

修正后的代码 #

use futures::lock::Mutex;
use futures_util::{future::Shared, Future, FutureExt};
use std::{pin::Pin, sync::Arc};
use tokio::time::Duration;

pub struct Token {
    pub token: String,
    pub requesting: Arc<Mutex<Option<Shared<Pin<Box<dyn Future<Output = Result<String, ()>> + Send>>>>>>,
}

// 独立的请求方法，不持有Token结构体的引用
async fn request_token_from_server() -> Result<String, ()> {
    tokio::time::sleep(Duration::from_secs(10)).await;
    Ok("test".to_owned())
}

impl Token {
    pub async fn access_token(&mut self) -> Result<String, ()> {
        // 先判断现有token是否有效，这里保留你原来的判断逻辑
        // if !self.token.is_expire() {
        //     return Ok(self.token.clone());
        // }

        // 先拿锁判断有没有正在进行的请求
        let mut req_guard = self.requesting.lock().await;
        let req = match req_guard.clone() {
            Some(existing_req) => {
                // 有正在进行的请求，直接拿共享Future，然后立刻释放锁
                drop(req_guard);
                existing_req
            }
            None => {
                // 没有正在进行的请求，创建新的请求Future
                let new_req = request_token_from_server().boxed().shared();
                *req_guard = Some(new_req.clone());
                // 存完立刻释放锁
                drop(req_guard);
                new_req
            }
        };

        // await请求结果，此时已经释放锁了，其他请求可以正常进入
        let token_res = req.await;

        // 请求成功后更新本地token，同时清空requesting缓存，方便下次过期发起新请求
        if let Ok(ref token) = token_res {
            self.token = token.clone();
            *self.requesting.lock().await = None;
        }

        token_res
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut token = Token {
        token: String::from(""),
        requesting: Arc::new(Mutex::new(None)),
    };
    let token_string = token.access_token().await;
    println!("{:?}", token_string);
    Ok(())
}

额外优化建议 #

如果你的Token实例需要在多线程环境下共享使用，建议把token字段也用Arc<Mutex<String>>包裹，把access_token方法的参数从&mut self改成&self，避免可变引用的限制，更适合多线程并发场景。

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