Rust中与外部进程的多线程通信

Question

rust 新手在这里。

我想启动一个外部长时间运行的进程，并通过 Rust 中的多个线程的管道与它交谈。

我遇到了终生错误，无法找到取悦终生检查器的正确方法。 有什么方法可以重组这个？

考虑以下示例：

use std::process::{Command, Stdio, ChildStdin};
use std::sync::Mutex;
use std::io::{Write};
use std::thread;

struct Element {
    sink: Mutex<Option<ChildStdin>>
}

impl Element {
    fn launch_process(&self) {
        let child =
            Command::new("sed").args(&["s/foo/bar/g"])
                .stdin(Stdio::piped())
                .spawn()
                .unwrap();

        let mut sink = self.sink.lock().unwrap();
        *sink = child.stdin;
    }

    fn tx(&self, content: &[u8]) {
        let mut sink = self.sink.lock().unwrap();
        sink.as_mut().unwrap().write(content);
    }

    fn start_tx(&self) {
        thread::spawn( || {
            self.tx(b"foo fighters");
        });
    }
}

fn main() {
    let e = Element {
        sink: Mutex::new(None)
    };

    e.launch_process();
    e.start_tx();
}

如果我删除thread::spawn位，那么一切都会按预期工作。 使用thread::spawn时，我收到错误：

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/main.rs:28:24
   |
28 |           thread::spawn( || {
   |  ________________________^
29 | |             self.tx(b"foo fighters");
30 | |         });
   | |_________^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 27:5...
  --> src/main.rs:27:5
   |
27 | /     fn start_tx(&self) {
28 | |         thread::spawn( || {
29 | |             self.tx(b"foo fighters");
30 | |         });
31 | |     }
   | |_____^
   = note: ...so that the types are compatible:
           expected &&Element
              found &&Element
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the type `[closure@src/main.rs:28:24: 30:10 self:&&Element]` will meet its required lifetime bounds
  --> src/main.rs:28:9
   |
28 |         thread::spawn( || {
   |         ^^^^^^^^^^^^^

error: aborting due to previous error

Answer 1

您不能将&self （临时借用）传递给线程，因为在引用不再有效后线程可能会继续运行。

要使用来自线程的数据，您只有两个选择：

• 将 object 的所有权（独占）赋予线程，即使用move || 关闭，然后不要尝试从主线程或任何其他线程使用该 object 。

• 在Arc中包装 object 以获得共享的线程安全所有权，并将克隆发送到线程（使用Arc::clone它很便宜并且底层数据是共享的）。

当编译器说你需要一个“静态生命周期”时，忽略它。 出于所有实际目的，这意味着“不允许引用”。

Answer 2

'static边界来自std::thread::spawn ，其定义为：

pub fn spawn<F, T>(f: F) -> JoinHandle<T> where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,

相同的文档还非常详细地解释了为什么需要该绑定。

为了克服它，您可以使用move关键字强制闭包获取捕获变量的所有权。 为此，您必须更改start_tx的签名，以便它采用值而不是引用：

impl Element {
    ...

    fn start_tx(self) {
        let _ = thread::spawn(move || {
            self.tx(b"foo fighters");
        });
    }
}

请注意，在调用此版本的start_tx之后，调用它的任何变量都将被消耗并且不再可用。

或者，您可以使用作用域线程 API。 Rust std曾经有std::thread::scoped ，但由于一些健全性问题而被弃用和删除。 现在几个 3rd 方库都有它，例如crossbeam crate：

use std::process::{Command, Stdio, ChildStdin};
use std::sync::Mutex;
use std::io::{Write};
use crossbeam_utils::thread;

struct Element {
    sink: Mutex<Option<ChildStdin>>
}

impl Element {
    ...

    fn start_tx(&self) {
        let _ = thread::scope(|_| {
            self.tx(b"foo fighters");
        });
    }
}

两者都有效，选择你的毒药。