Rust闭包触发‘borrowed data escapes outside of method’错误求解

问题根源 #

你的Window结构体强制要求回调必须是'static生命周期，但在run方法里传递的闭包捕获了仅在方法体内有效的&mut self（Application的引用），这个引用根本无法满足'static的永久存活要求。而实际上Window和Application是同生命周期的核心组件，完全不需要强制回调永久存活，只需要让回调的生命周期和这两个组件绑定即可。

修改后的代码（推荐方案） #

trait Event {}

// 给Window添加生命周期参数'a，关联回调的存活周期
struct Window<'a> {
    callback: Box<dyn FnMut(&mut dyn Event) -> bool + 'a>
}

impl<'a> Window<'a> {
    pub fn new() -> Self {
        Self {
            callback: Box::new(|_| false)
        }
    }
    
    // 把回调的生命周期约束从'static改成和Window一致的'a
    pub fn set_event_callback<C>(&mut self, callback: C) 
        where C: FnMut(&mut dyn Event) -> bool + 'a {
        self.callback = Box::new(callback);
    }
}

struct Application {
    data: i32
}

impl Application {
    pub fn new() -> Self {
        Self {
            data: 0
        }
    }
    
    pub fn run(&mut self) {
        // 创建和self同生命周期的Window实例
        let mut window = Window::new();
        
        window.set_event_callback(|event| {
            self.data += 1;
            false
        });
        // 这里可以添加窗口事件循环逻辑，比如window.run()
    }
}

fn main() {
    let mut app = Application::new();
    app.run();
}

关键调整说明 #

1. 给Window加生命周期参数：Window<'a>中的'a会自动绑定到创建它时的上下文生命周期，也就是run方法里&mut self的生命周期，保证回调和Application、Window同存活。
2. 放松回调的生命周期约束：把原来的'static换成'a，不再要求回调永久存活，只需要和Window一样久就行。
3. 规范main函数调用：把临时创建的Application绑定到变量，避免临时值被提前释放的问题。

备选方案：共享所有权（适合更灵活的场景） #

如果后续需要Window和Application的生命周期不完全绑定，可以用Arc<Mutex>实现共享所有权，让闭包满足'static要求：

use std::sync::{Arc, Mutex};

trait Event {}

struct Window {
    callback: Box<dyn FnMut(&mut dyn Event) -> bool + 'static>
}

impl Window {
    pub fn new() -> Self {
        Self {
            callback: Box::new(|_| false)
        }
    }
    
    pub fn set_event_callback<C>(&mut self, callback: C) 
        where C: FnMut(&mut dyn Event) -> bool + 'static {
        self.callback = Box::new(callback);
    }
}

struct Application {
    data: Mutex<i32>
}

impl Application {
    pub fn new() -> Arc<Self> {
        Arc::new(Self {
            data: Mutex::new(0)
        })
    }
    
    pub fn run(self: Arc<Self>) {
        let mut window = Window::new();
        let app_clone = self.clone();
        
        window.set_event_callback(move |event| {
            let mut data = app_clone.data.lock().unwrap();
            *data += 1;
            false
        });
    }
}

fn main() {
    let app = Application::new();
    app.run();
}

方案说明 #

通过Arc共享Application的所有权，Mutex保证多线程下的安全访问，闭包通过move捕获Arc的克隆，既满足'static要求，又能安全修改Application的内部数据。

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