Rust中捕获FnMut闭包生命周期不足问题求解

问题背景 #

需要实现一个包含回调闭包的struct，闭包需可变捕获外部状态，用于事件触发时通知用户。已有可行的概念验证版本，但将闭包封装到Foo结构体时出现编译错误：error[E0502]: cannot borrow 'abc' as immutable because it is also borrowed as mutable。

代码示例#1（可行的概念验证） #

fn main() {
    let mut abc = String::from("hello");
    
    let mut callback = || {
        abc.push_str(" world");
        println!("{}", abc);
    };
    
    // 触发回调
    callback();
    // 后续仍可正常使用abc
    println!("{}", abc);
}

代码示例#2（编译错误的封装版本） #

struct Foo {
    callback: Option<Box<dyn FnMut()>>,
}

impl Foo {
    fn new() -> Self {
        Foo { callback: None }
    }
    
    fn set_callback(&mut self, cb: Box<dyn FnMut()>) {
        self.callback = Some(cb);
    }
    
    fn trigger(&mut self) {
        if let Some(ref mut cb) = self.callback {
            cb();
        }
    }
}

fn main() {
    let mut abc = String::from("hello");
    
    let mut foo = Foo::new();
    foo.set_callback(Box::new(|| {
        abc.push_str(" world");
        println!("{}", abc);
    }));
    
    // 触发回调
    foo.trigger();
    
    // 此处编译报错：无法不可变借用abc，因为它已被可变借用
    println!("{}", abc);
}

错误原因 #

闭包在set_callback时可变捕获了abc，会创建一个对abc的可变借用，且该借用的生命周期与foo绑定（闭包被存储在foo内部）。后续尝试println!("{}", abc)时，相当于对abc发起不可变借用，违反了Rust的核心借用规则：同一时间只能存在一个可变借用，或多个不可变借用，二者不可共存。

解决方案 #

要保留闭包可变捕获外部状态的能力，同时不影响后续对原变量的使用，可通过引用计数+内部可变性的组合实现，常用工具为Rc<RefCell<T>>（单线程场景）或Arc<Mutex<T>>（多线程场景）。

单线程修正代码 #

use std::cell::RefCell;
use std::rc::Rc;

struct Foo {
    callback: Option<Box<dyn FnMut()>>,
}

impl Foo {
    fn new() -> Self {
        Foo { callback: None }
    }
    
    fn set_callback(&mut self, cb: Box<dyn FnMut()>) {
        self.callback = Some(cb);
    }
    
    fn trigger(&mut self) {
        if let Some(ref mut cb) = self.callback {
            cb();
        }
    }
}

fn main() {
    // 用Rc<RefCell>包装字符串，实现共享所有权与内部可变
    let abc = Rc::new(RefCell::new(String::from("hello")));
    // 克隆Rc实例供闭包捕获
    let abc_clone = Rc::clone(&abc);
    
    let mut foo = Foo::new();
    foo.set_callback(Box::new(move || {
        let mut inner = abc_clone.borrow_mut();
        inner.push_str(" world");
        println!("{}", inner);
    }));
    
    // 触发回调
    foo.trigger();
    
    // 正常不可变借用原变量
    println!("{}", abc.borrow());
}

方案说明 #

1. Rc<T>：提供引用计数式的共享所有权，克隆Rc仅增加引用计数，不复制底层数据，让闭包和原变量能同时持有对同一数据的引用。
2. RefCell<T>：实现内部可变性，允许在持有不可变引用的情况下修改内部数据，通过borrow_mut()获取可变引用、borrow()获取不可变引用，Rust会在运行时检查借用规则，避免数据竞争。
3. move关键字：让闭包获取abc_clone的所有权，确保闭包生命周期不受原变量作用域限制，同时借助Rc的特性，原abc仍可正常使用。

多线程场景适配方案 #

如果需要在多线程环境下运行，将Rc<RefCell>替换为Arc<Mutex>即可：

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

// Foo结构体及实现保持不变

fn main() {
    let abc = Arc::new(Mutex::new(String::from("hello")));
    let abc_clone = Arc::clone(&abc);
    
    let mut foo = Foo::new();
    foo.set_callback(Box::new(move || {
        let mut inner = abc_clone.lock().unwrap();
        inner.push_str(" world");
        println!("{}", inner);
    }));
    
    foo.trigger();
    println!("{}", abc.lock().unwrap());
}

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