rust - 在 Arc 和 Mutex 后面调用 Trait 对象的方法

Question

这playground project有我要编译的代码的简化版本。

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

pub trait Runnable {
    fn run(&mut self) -> Option<String>;
}

pub struct Value {}

impl Runnable for Value {
    fn run(&mut self) -> Option<String> {
        Some("Value".to_string())
    }
}

pub struct RunList {
    runnables: Vec<Arc<Mutex<Runnable>>>,
}

impl RunList {
    pub fn run<R>(&mut self, index: usize, mut runner: R)
    where
        R: FnMut(&mut MutexGuard<Runnable>),
    {
        let runnable_arc = self.runnables[index].clone();
        let mut runnable = runnable_arc.lock().unwrap();
        runner(&mut runnable);
    }
}

fn main() {
    let mut runnables = Vec::<Arc<Mutex<Runnable>>>::with_capacity(1);
    runnables.push(Arc::new(Mutex::new(Value {})));

    let mut run_list = RunList { runnables };

    run_list.run(0, |runnable| {
        println!("Hello, {}", runnable.run().unwrap());
    });
}

我想要一个 trait 对象的向量，其中每个对象都受到 Arc 和 Mutex 的保护，然后能够在每个对象上调用 trait 方法.

我有一个“借用的值不够长”的错误，但我看不出与 this question/answer 的区别。 .

error[E0597]: `runnable_arc` does not live long enough
  --> src/main.rs:25:28
   |
25 |         let mut runnable = runnable_arc.lock().unwrap();
   |                            ^^^^^^^^^^^^ borrowed value does not live long enough
26 |         runner(&mut runnable);
27 |     }
   |     - borrowed value only lives until here
   |
   = note: borrowed value must be valid for the static lifetime...

Answer 1

您似乎在编译器的推理系统中遇到了故障。改变 MutexGuard<Runnable>至 MutexGuard<Runnable + 'static>修复错误:

impl RunList {
    pub fn run<R>(&mut self, index: usize, mut runner: R)
    where
        R: FnMut(&mut MutexGuard<Runnable + 'static>),
    {
        let runnable_arc = self.runnables[index].clone();
        let mut runnable = runnable_arc.lock().unwrap();
        runner(&mut runnable);
    }
}

但有趣的是，将其更改为 MutexGuard<'static, Runnable + 'static>保留错误:

impl RunList {
    pub fn run<R>(&mut self, index: usize, mut runner: R)
    where
        R: FnMut(&mut MutexGuard<'static, Runnable + 'static>),
    {
        let runnable_arc = self.runnables[index].clone();
        let mut runnable = runnable_arc.lock().unwrap();
        runner(&mut runnable);
    }
}

为什么编译器会推断后者而不是前者？好吧，让我们看看 MutexGuard 的定义:

pub struct MutexGuard<'a, T: ?Sized + 'a> { /* fields omitted */ }

在MutexGuard<Runnable> , Runnable是一个特征对象并得到一个隐式 + 'static绑定(bind)，因为没有明确的生命周期。编译器似乎试图统一 'a 的两次出现。通过推理，如果我们需要用 'static 替换第二次出现，那么我们需要对第一次出现的情况做同样的事情。但是，该逻辑忘记了一个重要细节:'static比任何生命都长寿'a , 所以没有理由强制第一个 'a成为'static .事实上，当我们写 MutexGuard<Runnable + 'static> , 这与 MutexGuard<'a, Runnable + 'static> 相同(如何定义 'a 取决于上下文)。这是有效的，因为 Runnable + 'static: 'a (您始终可以将具有某个生命周期 'x 的对象作为参数传递给期望更短生命周期 'y 的函数)。

---

郑重声明，此问题与 FnMut 无关特征;一个正常的函数也显示了这种行为:

impl RunList {
    pub fn run(&mut self, index: usize) {
        fn runner2(runnable: &mut MutexGuard<Runnable>) {
            println!("Hello, {}", runnable.run().unwrap());
        }

        let runnable_arc = self.runnables[index].clone();
        let mut runnable = runnable_arc.lock().unwrap();
        runner2(&mut runnable);
    }
}