如何在多个线程之间共享引用？

Question

如何在多个线程之间共享引用？

4

我无法在线程之间共享引用。

trait Facade { /*some functions*/ }

struct Client<'a> {
    facade: &'a mut Facade,
    join_grd: thread::JoinGuard<'a()>,
}

impl<'a> Client<'a> {
    pub fn new(my_facade: &'a mut Facade) -> Client<'a> {
        Client {
            facade: my_facade,
        join_grd: thread::scoped(|| Client::start(my_facade)),
        }
    }

    fn start(my_facade: &'a mut Facade) { unimplemented!() }
}

作为Rust的新手，我对一些概念和错误感到困惑。我该如何实现上述目标？

- ustulation

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Vladimir Matveev · Accepted Answer

我很确定由于Rust中的可变别名保证，你不能这样做。在Rust中，你不能同时拥有两个对同一事物的可变引用，但这正是你的代码所发生的事情：你将my_facade存储到Client的字段中，同时又试图将它传递给另一个线程中的start()方法。这需要对同一个Facade拥有两个可变引用，这是不被允许的。

编译器实际上会报告一些错误，这是由于你正在使用一个非移动闭包。如果你将thread::scoped()的实例化更改为以下方式：

join_grd: thread::scoped(move || Client::start(my_facade))

错误信息应该更加合理：

test.rs:16:60: 16:69 error: cannot move `my_facade` into closure because it is borrowed
test.rs:16             join_grd: thread::scoped(move || Client::start(my_facade))
                                                                      ^~~~~~~~~
test.rs:15:21: 15:30 note: borrow of `*my_facade` occurs here
test.rs:15             facade: my_facade,
                               ^~~~~~~~~

这意味着由于&mut引用是唯一的并且被移动而不是复制，所以您无法复制它们。尝试使用常规的&引用替换&mut（并在Facade上添加一个附加的 Sync 父trait），相似的代码可以正常工作。

您需要重新考虑架构以解决此错误。仅从这段代码中很难理解您想要什么，因此我无法给出任何明确的建议，但如果您想在线程之间共享可变状态，则可以考虑使用Arc和Mutex。

像这样简单地使用Arc/Mutex:

fn start(my_facade: Arc<Mutex<Facade>>)

无法工作，因为Facade是一个特质，而不是一个常规类型。当您将特质用作类型时，实际上是选择使用特质对象的动态分派。简而言之，特质对象不能直接使用；它们应该始终在指针后面。您的原始程序还使用了特质对象（&'a mut Facade是一个特质对象）。理想情况下，我们应该能够使用任何类型的智能指针形成特质对象，而且理想情况下，Arc<Mutex<Facade>>应该可以工作，但不幸的是，目前只能使用&、&mut或Box创建特质对象：

fn start(my_facade: Arc<Mutex<Box<Facade>>>)

这是你观察到的关于错误的原因。

然而，你也应该考虑完全不使用特质对象，而只使用泛型：

trait Facade: Send { fn f(&self); }

struct Client<'a, F: Facade> {  // '
    facade: Arc<Mutex<F>>,
    join_grd: thread::JoinGuard<'a, ()>,  // '
}

impl<'a, F: Facade+'a> Client<'a, F> {  // '
    pub fn new(my_facade: Arc<Mutex<F>>) -> Client<'a, F> {  // '
        let my_facade_2 = my_facade.clone();  // clone the Arc pointer
        Client {
            facade: my_facade,
            join_grd: thread::scoped(move || Client::start(my_facade_2)),
        }
    }

    fn start(my_facade: Arc<Mutex<F>>) { unimplemented!() }
}

你还需要在trait本身上添加Send限定（如上面的示例）或者在F类型变量上添加Send限定（如F: Facade+Send+'a），因为只有Send数据才能够安全地在线程之间传输，所以你需要指定F是Send，可以直接指定，也可以作为Facade的超级trait约束。