Rust中subtyping与variance相关编译错误E0521求解

问题描述 #

我是Rust新手，当前遇到的问题与子类型（subtyping）和方差（variance）概念相关（依据cargo编译时的提示推测）。以下是我的代码及对应的编译错误信息，恳请解决该E0521错误：

use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, mpsc, Mutex};
use std::thread;

trait Draw {
    fn draw(&self);
}

#[derive(Default)]
struct Button {
    
}

impl Draw for Button {
    fn draw(&self) {
        println!("draw button");
    }
}

#[derive(Default)]
struct SelectionBox {
    
}

impl Draw for SelectionBox {
    fn draw(&self) {
        println!("draw selection box");
    }
}

#[derive(Default)]
struct TextField {
    
}

impl Draw for TextField {
    fn draw(&self) {
        println!("draw text field");
    }
}


pub struct RunningThreadInterface<T> {
    pub instance: Arc<T>,
    pub thread_join_handle: thread::JoinHandle<()>,
}

pub trait StartThread<T> {
    fn start(self, thread_id: String) -> RunningThreadInterface<T>;
    fn run(&self);
}

pub trait TerminateThread {
    fn stop(&mut self);
    fn wait(self);
}

struct Screen<'a> {
    widgets: Mutex<Vec<&'a (dyn Draw + Send + Sync)>>,
    rx: Mutex<mpsc::Receiver<String>>,
    terminate_flag: AtomicBool,
}

impl<'a> Screen<'a> {
    fn new(rx: mpsc::Receiver<String>) -> Screen<'a> {
        Screen {
            widgets: Mutex::new(Vec::new()),
            rx: Mutex::new(rx),
            terminate_flag: AtomicBool::new(false),
        }
    }
    
    fn add(&mut self, widget: &'a (dyn Draw + Send + Sync)) {
        self.widgets.lock().unwrap().push(widget);
    }
    
    fn draw_widgets(&self) {
        for widget in &*self.widgets.lock().unwrap() {
            widget.draw();
        }
    }
}


impl<'a> StartThread<Screen<'a>> for Screen<'a> {
    fn start(self, thread_id: String) -> RunningThreadInterface<Screen<'a>> {
        let screen = Arc::new(self);
        RunningThreadInterface {
            instance: Arc::clone(&screen),
            thread_join_handle: thread::Builder::new().name(thread_id).spawn(move || screen.run()).ok().unwrap(),
        }
    }

    fn run(&self) {
        while !self.terminate_flag.load(Ordering::SeqCst) {
            self.rx.lock().unwrap().recv().unwrap();
        }
    }
}

impl<'a> TerminateThread for RunningThreadInterface<Screen<'a>> {
    fn stop(&mut self) {
        self.instance.terminate_flag.store(true, Ordering::SeqCst);
    }

    fn wait(self) {
        self.thread_join_handle.join();
    }
}

fn main() {
    let button: Button = Default::default();
    let selection_box: SelectionBox = Default::default();
    let text_field: TextField = Default::default();
    
    let (_tx, rx) = mpsc::channel();
    
    let mut screen = Screen::new(rx);
    screen.add(&button);
    screen.add(&selection_box);
    screen.add(&text_field);
    
    screen.draw_widgets();
    
    println!("");
    
    button.draw();
    selection_box.draw();
    text_field.draw();
}

编译错误信息 #

error[E0521]: borrowed data escapes outside of method
  --> src/main.rs:90:33
   |
85 | impl<'a> StartThread<Screen<'a>> for Screen<'a> {
   |      -- lifetime `'a` defined here
86 |     fn start(self, thread_id: String) -> RunningThreadInterface<Screen<'a>> {
   |              ---- `self` is a reference that is only valid in the method body
...
90 |             thread_join_handle: thread::Builder::new().name(thread_id).spawn(move || screen.run()).ok().unwrap(),
   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                                 |
   |                                 `self` escapes the method body here
   |                                 argument requires that `'a` must outlive `'static`
   |
   = note: requirement occurs because of the type `Screen<'_>`, which makes the generic argument `'_` invariant
   = note: the struct `Screen<'a>` is invariant over the parameter `'a`
   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance

For more information about this error, try `rustc --explain E0521`.

错误原因分析 #

这个错误的核心是**Screen<'a>的生命周期无法满足线程的'static要求**：

• Rust的线程API要求闭包捕获的变量必须拥有'static生命周期，因为线程的运行时长不可控，编译器无法保证外部变量的生命周期能覆盖线程全程。
• Screen<'a>持有widget的引用，且它对生命周期'a是**不变（invariant）**的——也就是说，它不能被自动转换为更长的生命周期（比如'static），引用的有效性严格绑定到'a。
• 当把Screen封装进Arc传给线程时，线程会持有这个Arc，但Screen内部的'a生命周期并未延长到'static，编译器判定Screen实例（self）逃逸出了方法作用域，因为线程可能在'a结束后仍在运行。

解决方案 #

要解决问题，需要让Screen不再持有widget的引用，转而持有widget的共享所有权。通过将widget包裹在Arc中，Screen可以持有Arc<dyn Draw + Send + Sync>，从而消除生命周期限制。

修改后的代码如下：

use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, mpsc, Mutex};
use std::thread;

trait Draw {
    fn draw(&self);
}

#[derive(Default)]
struct Button {}

impl Draw for Button {
    fn draw(&self) {
        println!("draw button");
    }
}

#[derive(Default)]
struct SelectionBox {}

impl Draw for SelectionBox {
    fn draw(&self) {
        println!("draw selection box");
    }
}

#[derive(Default)]
struct TextField {}

impl Draw for TextField {
    fn draw(&self) {
        println!("draw text field");
    }
}

pub struct RunningThreadInterface<T> {
    pub instance: Arc<T>,
    pub thread_join_handle: thread::JoinHandle<()>,
}

pub trait StartThread<T> {
    fn start(self, thread_id: String) -> RunningThreadInterface<T>;
    fn run(&self);
}

pub trait TerminateThread {
    fn stop(&mut self);
    fn wait(self);
}

// 移除生命周期参数，持有Arc包裹的widget
struct Screen {
    widgets: Mutex<Vec<Arc<dyn Draw + Send + Sync>>>,
    rx: Mutex<mpsc::Receiver<String>>,
    terminate_flag: AtomicBool,
}

impl Screen {
    fn new(rx: mpsc::Receiver<String>) -> Screen {
        Screen {
            widgets: Mutex::new(Vec::new()),
            rx: Mutex::new(rx),
            terminate_flag: AtomicBool::new(false),
        }
    }
    
    // 修改add方法，接收Arc类型的widget
    fn add(&mut self, widget: Arc<dyn Draw + Send + Sync>) {
        self.widgets.lock().unwrap().push(widget);
    }
    
    fn draw_widgets(&self) {
        for widget in &*self.widgets.lock().unwrap() {
            widget.draw();
        }
    }
}

// 调整StartThread实现，Screen不再有生命周期参数
impl StartThread<Screen> for Screen {
    fn start(self, thread_id: String) -> RunningThreadInterface<Screen> {
        let screen = Arc::new(self);
        RunningThreadInterface {
            instance: Arc::clone(&screen),
            thread_join_handle: thread::Builder::new()
                .name(thread_id)
                .spawn(move || screen.run())
                .ok()
                .unwrap(),
        }
    }

    fn run(&self) {
        while !self.terminate_flag.load(Ordering::SeqCst) {
            // 忽略接收错误，比如通道关闭的情况
            let _ = self.rx.lock().unwrap().recv();
        }
    }
}

impl TerminateThread for RunningThreadInterface<Screen> {
    fn stop(&mut self) {
        self.instance.terminate_flag.store(true, Ordering::SeqCst);
    }

    fn wait(self) {
        // 忽略join错误
        let _ = self.thread_join_handle.join();
    }
}

fn main() {
    // 将widget包裹进Arc后再添加到Screen
    let button = Arc::new(Button::default());
    let selection_box = Arc::new(SelectionBox::default());
    let text_field = Arc::new(TextField::default());
    
    let (_tx, rx) = mpsc::channel();
    
    let mut screen = Screen::new(rx);
    screen.add(button.clone());
    screen.add(selection_box.clone());
    screen.add(text_field.clone());
    
    screen.draw_widgets();
    
    println!("");
    
    button.draw();
    selection_box.draw();
    text_field.draw();
}

关键修改说明 #

1. 移除Screen的生命周期参数：将widgets的类型从引用向量改为Arc包裹的trait对象向量，彻底消除对外部变量生命周期的依赖。
2. 调整add方法参数：接收Arc<dyn Draw + Send + Sync>类型，让Screen持有widget的共享所有权。
3. 修改main函数：将每个widget用Arc包裹，通过clone()传递共享所有权给Screen，同时保留原变量的所有权用于后续调用。
4. 优化线程逻辑：在run和wait方法中忽略非关键错误（比如通道关闭、线程join失败），避免程序panic。

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