结构体存储引用引发生命周期冲突问题求助（Tonic gRPC场景）

在使用tonic gRPC crate实现Web服务时，遇到了生命周期相关的编译错误。核心需求是在运行时根据条件将Vec<MyData>中的某个元素引用保存到结构体的data_ref字段中，但由于TonicGeneratedGrpcService是自动生成或第三方trait，无法修改其方法的&self生命周期参数。

原代码 #

use std::cell::RefCell;
use std::ops::{Deref, DerefMut};
use std::sync::Mutex;


fn main() {
    let my_struct = MyStruct {data_ref: RefCell::new(None), data: vec![MyData(28)]};
    my_struct.my_fun();
    // my_struct.my_fun_is_gone(); This is not working.
    println!("{}", my_struct.data_ref.borrow().deref().unwrap().0);
}

/// AUTO GENERATED CODE OR THIRD PARTY TRAITS
///for example tonic generated Grpc services
trait TonicGeneratedGrpcService {
    fn my_fun_is_gone(&self); //so I Can't change the &self lifetime parameter
}

struct MyData(u8);
struct MyStruct<'a> {
    data: Vec<MyData>, //this struct is owns this property, there is no any problem
    data_ref: RefCell<Option<&'a MyData>>, //And sometimes I want to save the data
}

impl<'a> TonicGeneratedGrpcService for MyStruct<'a> {
    fn my_fun_is_gone(&self) { //I can't change the &self lifetime parameter because this is just an implementation of some super traits, change the lifetime parameters also requires change the super trait's method's lifetime.

//***********COMPILER ERROR is occurred HERE, how can I make this working?*************
        let some_of_data = &self.data[0]; //Maybe &self.data[1], &self.data[2]...
        *self.data_ref.borrow_mut() = Some(some_of_data);
    }
}

impl<'a> MyStruct<'a> {
    //Below code is works fine if this is myself defined method, but I can't change the lifetime of "self" in super traits if this is a implementation of tonic generated service or other third party traits
    fn my_fun(&'a self) {
        let some_of_data = &self.data[0]; //Maybe &self.data[1], &self.data[2]...
        *self.data_ref.borrow_mut() = Some(some_of_data);
    }
}

编译错误信息 #

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
  --> src/main.rs:28:29
   |
28 |         let some_of_data = &self.data[0]; //Maybe &self.data[1], &self.data[2]...
   |                             ^^^^^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime defined here...
  --> src/main.rs:26:23
   |
26 |     fn my_fun_is_gone(&self) { //I can't change the &self lifetime parameter because this is just an implementation of some super traits,...
   |                       ^^^^^
note: ...so that reference does not outlive borrowed content
  --> src/main.rs:28:29
   |
28 |         let some_of_data = &self.data[0]; //Maybe &self.data[1], &self.data[2]...
   |                             ^^^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined here...
  --> src/main.rs:25:6
   |
25 | impl<'a> TonicGeneratedGrpcService for MyStruct<'a> {
   |      ^^
note: ...so that the expression is assignable
  --> src/main.rs:29:39
   |
29 |         *self.data_ref.borrow_mut() = Some(some_of_data);
   |                                       ^^^^^^^^^^^^^^^^^^
   = note: expected `Option<&'a MyData>`
              found `Option<&MyData>`

问题原因 #

编译错误的核心在于：trait方法my_fun_is_gone中的&self是匿名临时生命周期，而data_ref需要的是和结构体生命周期'a绑定的引用。临时生命周期无法满足'a的要求，因为编译器无法保证临时借用的引用能和结构体存活一样久。

解决方案：使用引用计数指针Rc/Arc #

由于无法修改第三方trait的方法签名，生命周期约束无法满足，此时需要改用共享所有权的方式来保存引用，Rc（单线程场景）或Arc（多线程场景，tonic服务通常需要）是最合适的选择。通过引用计数，我们可以摆脱生命周期的绑定，让data_ref持有和原数据同生命周期的共享引用。

修改后的完整代码 #

use std::cell::RefCell;
use std::rc::Rc; // 单线程场景用Rc，多线程替换为Arc

fn main() {
    let my_struct = MyStruct {
        data_ref: RefCell::new(None),
        data: vec![Rc::new(MyData(28))], // 用Rc包裹MyData
    };
    my_struct.my_fun_is_gone(); // 现在可以正常调用
    println!("{}", my_struct.data_ref.borrow().as_ref().unwrap().0);
}

/// 第三方/自动生成的trait，无需修改
trait TonicGeneratedGrpcService {
    fn my_fun_is_gone(&self);
}

struct MyData(u8);
struct MyStruct {
    data: Vec<Rc<MyData>>, // Vec存储Rc<MyData>
    data_ref: RefCell<Option<Rc<MyData>>>, // 保存Rc<MyData>而非引用
}

impl TonicGeneratedGrpcService for MyStruct {
    fn my_fun_is_gone(&self) {
        // 克隆Rc，共享所有权，无需担心生命周期
        let some_of_data = Rc::clone(&self.data[0]);
        *self.data_ref.borrow_mut() = Some(some_of_data);
    }
}

impl MyStruct {
    fn my_fun(&self) {
        let some_of_data = Rc::clone(&self.data[0]);
        *self.data_ref.borrow_mut() = Some(some_of_data);
    }
}

关键改动说明 #

1. 移除生命周期参数：MyStruct不再需要'a生命周期，因为Rc通过引用计数管理所有权，无需依赖结构体的生命周期。
2. 用Rc/Arc包裹MyData：将Vec<MyData>改为Vec<Rc<MyData>>（多线程场景用Arc），让结构体和data_ref共享MyData的所有权。
3. 修改data_ref类型：RefCell<Option<&'a MyData>>改为RefCell<Option<Rc<MyData>>>，保存共享所有权的Rc而非引用。
4. 克隆Rc而非取引用：在方法中通过Rc::clone获取共享引用，这个操作是轻量级的（仅增加引用计数），且不会引入生命周期问题。

如果你的tonic服务是多线程场景，只需将Rc替换为Arc，若需要内部可变性，结合Mutex或RwLock使用即可（比如Arc<Mutex<MyData>>）。

内容的提问来源于stack exchange，提问作者Ug-Projekt