您如何用弧< mutex< ..>>

Question

我正在尝试调用一个函数，该函数将指针用于某些特征对象的Mutex，我希望能够实现该特征对象的Mutex的性状Mutex作为抽象特征对象的实例。

举一个例子，想象一下Event听众设置：

use std::sync::{Arc, Mutex, Weak};
// Define a simple event
trait Event: Send + Sync + 'static {}
impl Event for String {}

// Define the listener interface
trait Listener<E: Event> {
    fn notify(&self, event: &E);
}
// Extend the listener interface to listenrs wrapped by a mutex
impl<E: Event> Listener<E> for Mutex<Listener<E>> {
    fn notify(&self, event: &E) {
        self.lock().unwrap().notify(event);
    }
}

// Contrived thing to listen for messages
struct Console;
impl Listener<String> for Console {
    fn notify(&self, event: &String) {
        println!("{}", event);
    }
}

// Simple function which may be called asynchronously and then sends a message
// when it is complete
fn do_stuff(l: Arc<Listener<String>>) {
    // Would normally cast to a Weak<...> and then store in a list of listneners
    // For some sort of object
    let m = String::from("I did stuff!");
    l.notify(&m);
}
fn main() {
    let l: Arc<Mutex<Console>> = Arc::new(Mutex::new(Console));
    let t1 = Arc::clone(&l) as Arc<Mutex<Listener<String>>>; //this part is ok
    // Here is where we run into issues... This *should* be equvlient to
    // do_stuff(t1), but with the corercion explicit
    let t2 = Arc::clone(&t1) as Arc<Listener<String>>;
    do_stuff(t2);
    // This is a simple, working example of it interpreting a Mutex<Listener<E>>
    // as just a Listener<E>
    let m = String::from("Somthing else...");
    (l as Arc<Mutex<Listener<String>>>).notify(&m);
}

（游乐场）

问题是：

error[E0277]: the trait bound `Listener<std::string::String>: std::marker::Sized` is not satisfied in `std::sync::Mutex<Listener<std::string::String>>`
  --> src/main.rs:45:14
   |
45 |     let t2 = Arc::clone(&t1) as Arc<Listener<String>>;
   |              ^^^^^^^^^^^^^^^ `Listener<std::string::String>` does not have a constant size known at compile-time
   |
   = help: within `std::sync::Mutex<Listener<std::string::String>>`, the trait `std::marker::Sized` is not implemented for `Listener<std::string::String>`
   = note: required because it appears within the type `std::sync::Mutex<Listener<std::string::String>>`
   = note: required for the cast to the object type `Listener<std::string::String>`

为什么是这种情况？由于Arc是指向数据的指针，因此，从我的理解中，它应该能够指向恰好是Listener<Mutex<String>>的Listener<String>。

我看到至少两种避免这种情况的方法，第一个是简单的impl Listener<String> for Mutex<Listener<String>>，但是，在实际代码中，这可能需要相互依存，应该避免，因为只能在定义特征或结构的情况下实现特征（并且Mutex未在我的代码中定义）。

第二个是将Mutex移动到Listener对象中，以便呼叫者根本不需要投放它。这将起作用，并且可能是更好的解决方案。尽管如此，我还是很好奇为什么提议的演员不起作用，或者可以更改以使其起作用的原因。

Answer 1

由于Arc是指向数据的指针，因此，从我的理解中，它应该能够指向Listener<String>

是的，是的。我相信您的问题是您（偶然地？）要求您在某个时候拥有Mutex<Listener<String>>。这是不是有效的，因为Mutex内部的值不在指针后面，因此使整个类型都没有介绍。

虽然有一个Arc<Mutex<Listener<String>>>。

相反，我将实现的Mutex的特征，以实现相同特征的任何类型。对于特征的参考和Box ED特质对象，我也会做同样的事情。在所有情况下，我都会删除Sized绑定以允许特征对象：

use std::sync::{Arc, Mutex};
trait Event: Send + Sync + 'static {}
impl Event for String {}
trait Listener<E: Event> {
    fn notify(&self, event: &E);
}
impl<L, E> Listener<E> for Mutex<L>
where
    L: ?Sized + Listener<E>,
    E: Event,
{
    fn notify(&self, event: &E) {
        self.lock().unwrap().notify(event);
    }
}
impl<'a, L, E> Listener<E> for &'a L
where
    L: ?Sized + Listener<E>,
    E: Event,
{
    fn notify(&self, event: &E) {
        (**self).notify(event);
    }
}
struct Console;
impl Listener<String> for Console {
    fn notify(&self, event: &String) {
        println!("{}", event);
    }
}
fn do_stuff(l: Arc<Listener<String>>) {
    let m = String::from("I did stuff!");
    l.notify(&m);
}
fn main() {
    let l: Arc<Mutex<Console>> = Arc::new(Mutex::new(Console));
    let l2 = Arc::clone(&l) as Arc<Listener<String>>;
    let l3 = Arc::clone(&l) as Arc<Listener<String>>;
    do_stuff(l);
    do_stuff(l2);
    let m = String::from("Something else...");
    l3.notify(&m);
}